View Javadoc

1   /* Generated By:JJTree&JavaCC: Do not edit this line. PLSQLParser.java */
2   /* Copyright (C) 2002 Albert Tumanov
3   
4   This library is free software; you can redistribute it and/or
5   modify it under the terms of the GNU Lesser General Public
6   License as published by the Free Software Foundation; either
7   version 2.1 of the License, or (at your option) any later version.
8   
9   This library is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  Lesser General Public License for more details.
13  
14  You should have received a copy of the GNU Lesser General Public
15  License along with this library; if not, write to the Free Software
16  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  
18  */
19  
20  package net.sourceforge.pmd.lang.plsql.ast;
21  
22  import java.io.*;
23  import net.sourceforge.pmd.lang.ast.Node;
24  import net.sourceforge.pmd.lang.ast.SimpleCharStream;
25  import net.sourceforge.pmd.lang.ast.TokenMgrError;
26  
27  public class PLSQLParser/*@bgen(jjtree)*/implements PLSQLParserTreeConstants, PLSQLParserConstants {/*@bgen(jjtree)*/
28    protected JJTPLSQLParserState jjtree = new JJTPLSQLParserState();
29    /**
30     * main method, for testing only.
31     * @param args
32     */
33    public static void main(String[] args)
34        throws ParseException {
35  
36      PLSQLParser parser = new PLSQLParser(System.in);
37      PLSQLNode node = parser.Input();
38  
39      String s;
40      s = "qwerty";
41  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
42      s = "\u005c"qwerty\u005c"";
43  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
44      s = "\u005c"qwerty\u005c".uiop";
45  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
46      s = "\u005c"qwerty\u005c".\u005c"uiop\u005c"";
47  //    System.err.println(s + " -> " + parser.purifyIdentifier(s));
48    }
49  
50    /**
51     Return canonical version of the Oracle
52    */
53    public static String canonicalName(String name)
54    {
55      StringBuilder s =  null ;
56  
57  
58      if (null == name) {
59        return name;
60      }
61      else if (-1 == name.indexOf('"') )
62      {
63        name = name.toUpperCase();
64        s = new StringBuilder(name.trim());
65      }
66      else
67      {
68        StringBuilder oldString = new StringBuilder( name.trim().length());
69        s = new StringBuilder(name.trim());
70        boolean quotedCharacter = false ;
71        for (int i=0; i<oldString.length(); i++) {
72          if (oldString.charAt(i) == '"')
73          {
74  
75            oldString.deleteCharAt(i);
76            i--;
77  
78            //Toggle whether following characters are quoted or not
79            quotedCharacter = !quotedCharacter ;
80          }
81          else
82          {
83            s.append( quotedCharacter
84                      ? s.charAt(i)
85                      : Character.toUpperCase(s.charAt(i))
86                    );
87          }
88        }
89      }
90      return s.toString();
91    }
92  
93  /**
94   * 2006-05-22 - Matthias Hendler - Added parsing of triggers and global functions/procedures
95   *                                 Refactored printing of custom tags into the XML/DOM.
96   *                                 Custom tags are language independent. Reserved tags are linked
97   *                                 to the documented language like RETURN, PARAM and THROWS.
98   */
99  
100 /**
101  * 2006-05-22 - Matthias Hendler - added globalBody()
102  */
103   final public ASTInput Input() throws ParseException {
104                     /*@bgen(jjtree) Input */
105   ASTInput jjtn000 = new ASTInput(this, JJTINPUT);
106   boolean jjtc000 = true;
107   jjtree.openNodeScope(jjtn000);
108     try {
109       label_1:
110       while (true) {
111         switch (jj_nt.kind) {
112         case 2:
113         case 3:
114         case 21:
115         case ALTER:
116         case BEGIN:
117         case COLUMN:
118         case COMMENT:
119         case COMMIT:
120         case CONNECT:
121         case CREATE:
122         case DECLARE:
123         case DELETE:
124         case DROP:
125         case EXECUTE:
126         case EXIT:
127         case FUNCTION:
128         case GRANT:
129         case INSERT:
130         case LOCK:
131         case MERGE:
132         case PACKAGE:
133         case PROMPT:
134         case PROCEDURE:
135         case RENAME:
136         case REVOKE:
137         case ROLLBACK:
138         case SAVEPOINT:
139         case SELECT:
140         case SET:
141         case START:
142         case TRIGGER:
143         case TYPE:
144         case SHOW:
145         case SPOOL:
146         case UPDATE:
147         case WITH:
148         case ANALYZE:
149         case ASSOCIATE:
150         case AUDIT:
151         case DDL:
152         case DISASSOCIATE:
153         case NOAUDIT:
154         case TRUNCATE:
155         case ACCEPT:
156         case COPY:
157         case DEFINE:
158         case DISCONNECT:
159         case HOST:
160         case PRINT:
161         case QUIT:
162         case REMARK:
163         case UNDEFINE:
164         case VARIABLE:
165         case WHENEVER:
166         case IDENTIFIER:
167           ;
168           break;
169         default:
170           jj_la1[0] = jj_gen;
171           break label_1;
172         }
173         if (jj_2_1(6)) {
174           PackageSpecification();
175         } else if (jj_2_2(6)) {
176           PackageBody();
177         } else if (jj_2_3(6)) {
178           TypeSpecification();
179         } else if (jj_2_4(6)) {
180           Table();
181         } else if (jj_2_5(6)) {
182           View();
183         } else if (jj_2_6(6)) {
184           TriggerUnit();
185         } else if (jj_2_7(6)) {
186           AlterTrigger();
187         } else if (jj_2_8(6)) {
188           Synonym();
189         } else if (jj_2_9(6)) {
190           Directory();
191         } else if (jj_2_10(6)) {
192           DatabaseLink();
193         } else if (jj_2_11(6)) {
194           Global();
195         } else if (jj_2_12(6)) {
196           DDLCommand();
197         } else if (jj_2_13(2)) {
198           SqlPlusCommand();
199         } else {
200           switch (jj_nt.kind) {
201           case COMMIT:
202           case DELETE:
203           case INSERT:
204           case LOCK:
205           case MERGE:
206           case ROLLBACK:
207           case SAVEPOINT:
208           case SELECT:
209           case UPDATE:
210           case WITH:
211             switch (jj_nt.kind) {
212             case SELECT:
213               jj_consume_token(SELECT);
214               break;
215             case UPDATE:
216               jj_consume_token(UPDATE);
217               break;
218             case INSERT:
219               jj_consume_token(INSERT);
220               break;
221             case DELETE:
222               jj_consume_token(DELETE);
223               break;
224             case COMMIT:
225               jj_consume_token(COMMIT);
226               break;
227             case ROLLBACK:
228               jj_consume_token(ROLLBACK);
229               break;
230             case SAVEPOINT:
231               jj_consume_token(SAVEPOINT);
232               break;
233             case LOCK:
234               jj_consume_token(LOCK);
235               jj_consume_token(TABLE);
236               break;
237             case MERGE:
238               jj_consume_token(MERGE);
239               break;
240             case WITH:
241               jj_consume_token(WITH);
242               break;
243             default:
244               jj_la1[1] = jj_gen;
245               jj_consume_token(-1);
246               throw new ParseException();
247             }
248             SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
249             break;
250           default:
251             jj_la1[2] = jj_gen;
252             jj_consume_token(-1);
253             throw new ParseException();
254           }
255         }
256         label_2:
257         while (true) {
258           switch (jj_nt.kind) {
259           case 1:
260             ;
261             break;
262           default:
263             jj_la1[3] = jj_gen;
264             break label_2;
265           }
266           jj_consume_token(1);
267         }
268       }
269       jj_consume_token(0);
270         jjtree.closeNodeScope(jjtn000, true);
271         jjtc000 = false;
272         {if (true) return jjtn000 ;}
273     } catch (Throwable jjte000) {
274           if (jjtc000) {
275             jjtree.clearNodeScope(jjtn000);
276             jjtc000 = false;
277           } else {
278             jjtree.popNode();
279           }
280           if (jjte000 instanceof RuntimeException) {
281             {if (true) throw (RuntimeException)jjte000;}
282           }
283           if (jjte000 instanceof ParseException) {
284             {if (true) throw (ParseException)jjte000;}
285           }
286           {if (true) throw (Error)jjte000;}
287     } finally {
288           if (jjtc000) {
289             jjtree.closeNodeScope(jjtn000, true);
290           }
291     }
292     throw new Error("Missing return statement in function");
293   }
294 
295   final public ASTDDLCommand DDLCommand() throws ParseException {
296  /*@bgen(jjtree) DDLCommand */
297  ASTDDLCommand jjtn000 = new ASTDDLCommand(this, JJTDDLCOMMAND);
298  boolean jjtc000 = true;
299  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
300     try {
301       simpleNode = DDLEvent();
302       SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
303     jjtree.closeNodeScope(jjtn000, true);
304     jjtc000 = false;
305     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
306     } catch (Throwable jjte000) {
307     if (jjtc000) {
308       jjtree.clearNodeScope(jjtn000);
309       jjtc000 = false;
310     } else {
311       jjtree.popNode();
312     }
313     if (jjte000 instanceof RuntimeException) {
314       {if (true) throw (RuntimeException)jjte000;}
315     }
316     if (jjte000 instanceof ParseException) {
317       {if (true) throw (ParseException)jjte000;}
318     }
319     {if (true) throw (Error)jjte000;}
320     } finally {
321     if (jjtc000) {
322       jjtree.closeNodeScope(jjtn000, true);
323     }
324     }
325     throw new Error("Missing return statement in function");
326   }
327 
328   final public ASTSqlPlusCommand SqlPlusCommand() throws ParseException {
329  /*@bgen(jjtree) SqlPlusCommand */
330  ASTSqlPlusCommand jjtn000 = new ASTSqlPlusCommand(this, JJTSQLPLUSCOMMAND);
331  boolean jjtc000 = true;
332  jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder() ;
333     try {
334       switch (jj_nt.kind) {
335       case 2:
336         jj_consume_token(2);
337         break;
338       case ACCEPT:
339         jj_consume_token(ACCEPT);
340         break;
341       case COLUMN:
342         jj_consume_token(COLUMN);
343         break;
344       case CONNECT:
345         jj_consume_token(CONNECT);
346         break;
347       case COPY:
348         jj_consume_token(COPY);
349         break;
350       case DEFINE:
351         jj_consume_token(DEFINE);
352         break;
353       case DISCONNECT:
354         jj_consume_token(DISCONNECT);
355         break;
356       case EXECUTE:
357         jj_consume_token(EXECUTE);
358         break;
359       case EXIT:
360         jj_consume_token(EXIT);
361         break;
362       case HOST:
363         jj_consume_token(HOST);
364         break;
365       case PRINT:
366         jj_consume_token(PRINT);
367         break;
368       case PROMPT:
369         jj_consume_token(PROMPT);
370         break;
371       case QUIT:
372         jj_consume_token(QUIT);
373         break;
374       case REMARK:
375         jj_consume_token(REMARK);
376         break;
377       case SET:
378         jj_consume_token(SET);
379         break;
380       case SHOW:
381         jj_consume_token(SHOW);
382         break;
383       case SPOOL:
384         jj_consume_token(SPOOL);
385         break;
386       case START:
387         jj_consume_token(START);
388         break;
389       case UNDEFINE:
390         jj_consume_token(UNDEFINE);
391         break;
392       case VARIABLE:
393         jj_consume_token(VARIABLE);
394         break;
395       case WHENEVER:
396         jj_consume_token(WHENEVER);
397         break;
398       case COMMENT:
399         jj_consume_token(COMMENT);
400         break;
401       case GRANT:
402         jj_consume_token(GRANT);
403         break;
404       case REVOKE:
405         jj_consume_token(REVOKE);
406         break;
407       case DROP:
408         jj_consume_token(DROP);
409         break;
410       case IDENTIFIER:
411         jj_consume_token(IDENTIFIER);
412         break;
413       case 3:
414         jj_consume_token(3);
415         jj_consume_token(ATTACH);
416         break;
417       default:
418         jj_la1[4] = jj_gen;
419         jj_consume_token(-1);
420         throw new ParseException();
421       }
422     sb.append(token.image) ; sb.append(" ...") ;
423       Skip2NextTokenOccurrence(EOL);
424     jjtree.closeNodeScope(jjtn000, true);
425     jjtc000 = false;
426     jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
427     } catch (Throwable jjte000) {
428     if (jjtc000) {
429       jjtree.clearNodeScope(jjtn000);
430       jjtc000 = false;
431     } else {
432       jjtree.popNode();
433     }
434     if (jjte000 instanceof RuntimeException) {
435       {if (true) throw (RuntimeException)jjte000;}
436     }
437     if (jjte000 instanceof ParseException) {
438       {if (true) throw (ParseException)jjte000;}
439     }
440     {if (true) throw (Error)jjte000;}
441     } finally {
442     if (jjtc000) {
443       jjtree.closeNodeScope(jjtn000, true);
444     }
445     }
446     throw new Error("Missing return statement in function");
447   }
448 
449 /*
450 SRT 2011-04-17 This syntax breaks the parser when fields of record.attach* are referenced  in PL/SQL 
451 void attachLibrary() :
452 {}
453 {
454 	<".attach"> <IDENTIFIER> <IDENTIFIER> <END> <IDENTIFIER>
455 }
456 */
457 
458 /**
459  * All global definitions of triggers, functions and procedures are evaluated here.
460  * Every occurence goes under a new PACKAGE-Node in the XML document.
461  * This happens, cause a global "block" does not have a definied start and end token 
462  * like a package specification or a package body.
463  * Thats why every construct is handled like a new part of the global package.
464  * To overcome this problem, I could use an infinity lookahead - which should solve the problem 
465  * and slow down the whole parsing.
466  * Another idea would be to lookahead the next tokens and decide wether they belong to a package definition or not.
467  * Then I could decide to stay in this global parsing state. By now lookahead gives the parser a hint to
468  * choose the correct way on a given base. So we can't negate it easily.
469  * On the other hand I could also hold the global state in a global variable. 
470  * But this does not seems the correct way to solve the problem, I think.
471  *
472  * 2006-05-17 - Matthias Hendler - added
473  */
474   final public ASTGlobal Global() throws ParseException {
475  /*@bgen(jjtree) Global */
476   ASTGlobal jjtn000 = new ASTGlobal(this, JJTGLOBAL);
477   boolean jjtc000 = true;
478   jjtree.openNodeScope(jjtn000);
479     try {
480       if (jj_2_14(2147483647)) {
481         label_3:
482         while (true) {
483           switch (jj_nt.kind) {
484           case 21:
485             ;
486             break;
487           default:
488             jj_la1[5] = jj_gen;
489             break label_3;
490           }
491           Label();
492         }
493         Block();
494         jj_consume_token(4);
495       } else if (jj_2_15(4)) {
496         ProgramUnit();
497       } else {
498         jj_consume_token(-1);
499         throw new ParseException();
500       }
501         jjtree.closeNodeScope(jjtn000, true);
502         jjtc000 = false;
503         {if (true) return jjtn000 ;}
504     } catch (Throwable jjte000) {
505           if (jjtc000) {
506             jjtree.clearNodeScope(jjtn000);
507             jjtc000 = false;
508           } else {
509             jjtree.popNode();
510           }
511           if (jjte000 instanceof RuntimeException) {
512             {if (true) throw (RuntimeException)jjte000;}
513           }
514           if (jjte000 instanceof ParseException) {
515             {if (true) throw (ParseException)jjte000;}
516           }
517           {if (true) throw (Error)jjte000;}
518     } finally {
519           if (jjtc000) {
520             jjtree.closeNodeScope(jjtn000, true);
521           }
522     }
523     throw new Error("Missing return statement in function");
524   }
525 
526   final public ASTBlock Block() throws ParseException {
527  /*@bgen(jjtree) Block */
528   ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
529   boolean jjtc000 = true;
530   jjtree.openNodeScope(jjtn000);
531     try {
532       switch (jj_nt.kind) {
533       case DECLARE:
534         jj_consume_token(DECLARE);
535         DeclarativeSection();
536         break;
537       default:
538         jj_la1[6] = jj_gen;
539         ;
540       }
541       jj_consume_token(BEGIN);
542       label_4:
543       while (true) {
544         switch (jj_nt.kind) {
545         case 5:
546         case 16:
547         case 17:
548         case 21:
549         case REPLACE:
550         case DEFINER:
551         case CURRENT_USER:
552         case LANGUAGE:
553         case ADD:
554         case AGGREGATE:
555         case ARRAY:
556         case AT:
557         case ATTRIBUTE:
558         case AUTHID:
559         case BEGIN:
560         case BODY:
561         case BULK:
562         case BYTE:
563         case CASCADE:
564         case CASE:
565         case CLOSE:
566         case COALESCE:
567         case COLLECT:
568         case COLUMN:
569         case COMMENT:
570         case COMMIT:
571         case CONSTRUCTOR:
572         case CONTINUE:
573         case CONVERT:
574         case CURRENT:
575         case CURSOR:
576         case DATA:
577         case DATE:
578         case DAY:
579         case DECLARE:
580         case DELETE:
581         case DISABLE:
582         case EDITIONABLE:
583         case ELEMENT:
584         case ENABLE:
585         case ESCAPE:
586         case EXCEPT:
587         case EXCEPTIONS:
588         case EXECUTE:
589         case EXIT:
590         case EXTERNAL:
591         case EXTENDS:
592         case EXTRACT:
593         case FALSE:
594         case FETCH:
595         case FINAL:
596         case FOR:
597         case FORALL:
598         case FORCE:
599         case FUNCTION:
600         case GLOBAL:
601         case GOTO:
602         case HASH:
603         case HEAP:
604         case HOUR:
605         case IF:
606         case IMMEDIATE:
607         case INDICES:
608         case INDEXTYPE:
609         case INDICATOR:
610         case INSERT:
611         case INSTANTIABLE:
612         case INTERVAL:
613         case INVALIDATE:
614         case ISOLATION:
615         case JAVA:
616         case LEVEL:
617         case LIMIT:
618         case LOCK:
619         case LOOP:
620         case MAP:
621         case MAX:
622         case MEMBER:
623         case MERGE:
624         case MIN:
625         case MINUTE:
626         case MLSLABEL:
627         case MODIFY:
628         case MOD:
629         case MONTH:
630         case NATURAL:
631         case NEW:
632         case NEW_DOT:
633         case NO:
634         case NONEDITIONABLE:
635         case NOT:
636         case NULL:
637         case NULLIF:
638         case OBJECT:
639         case OID:
640         case OPAQUE:
641         case OPEN:
642         case OPERATOR:
643         case ORGANIZATION:
644         case OTHERS:
645         case OVERRIDING:
646         case PACKAGE:
647         case PARTITION:
648         case PIPE:
649         case PRESERVE:
650         case PRIVATE:
651         case PROCEDURE:
652         case RAISE:
653         case RANGE:
654         case RAW:
655         case REAL:
656         case RECORD:
657         case REF:
658         case RELEASE:
659         case RELIES_ON:
660         case RENAME:
661         case RESULT:
662         case RETURN:
663         case RETURNING:
664         case REVERSE:
665         case ROLLBACK:
666         case ROW:
667         case ROWS:
668         case ROWID:
669         case ROWNUM:
670         case SAVE:
671         case SAVEPOINT:
672         case SECOND:
673         case SELECT:
674         case SELF:
675         case SET:
676         case SPACE:
677         case SQL:
678         case SQLCODE:
679         case SQLERRM:
680         case STATIC:
681         case SUBTYPE:
682         case SUBSTITUTABLE:
683         case SUCCESSFUL:
684         case SYSDATE:
685         case SYS_REFCURSOR:
686         case TEMPORARY:
687         case TIME:
688         case TIMESTAMP:
689         case TIMEZONE_REGION:
690         case TIMEZONE_ABBR:
691         case TIMEZONE_MINUTE:
692         case TIMEZONE_HOUR:
693         case TRANSACTION:
694         case TRUE:
695         case TYPE:
696         case UNDER:
697         case USING:
698         case WHILE:
699         case YES:
700         case SHOW:
701         case A:
702         case UPDATE:
703         case DOUBLE:
704         case DEC:
705         case PRECISION:
706         case INT:
707         case NUMERIC:
708         case NCHAR:
709         case NVARCHAR2:
710         case STRING:
711         case UROWID:
712         case VARRAY:
713         case VARYING:
714         case BFILE:
715         case BLOB:
716         case CLOB:
717         case NCLOB:
718         case YEAR:
719         case LOCAL:
720         case WITH:
721         case ZONE:
722         case CHARACTER:
723         case AFTER:
724         case BEFORE:
725         case OLD:
726         case PARENT:
727         case CC_IF:
728         case CC_ERROR:
729         case ANALYZE:
730         case ASSOCIATE:
731         case AUDIT:
732         case COMPOUND:
733         case DATABASE:
734         case CALL:
735         case DDL:
736         case DISASSOCIATE:
737         case EACH:
738         case FOLLOWS:
739         case LOGOFF:
740         case LOGON:
741         case NESTED:
742         case NOAUDIT:
743         case SCHEMA:
744         case SERVERERROR:
745         case SHUTDOWN:
746         case STARTUP:
747         case STATEMENT:
748         case STATISTICS:
749         case SUSPEND:
750         case TRUNCATE:
751         case WRAPPED:
752         case LIBRARY:
753         case NAME:
754         case STRUCT:
755         case CONTEXT:
756         case PARAMETERS:
757         case LENGTH:
758         case TDO:
759         case MAXLEN:
760         case CHARSETID:
761         case CHARSETFORM:
762         case ACCEPT:
763         case ACCESSIBLE:
764         case COPY:
765         case DEFINE:
766         case DISCONNECT:
767         case HOST:
768         case PRINT:
769         case QUIT:
770         case REMARK:
771         case UNDEFINE:
772         case VARIABLE:
773         case WHENEVER:
774         case ATTACH:
775         case CAST:
776         case TREAT:
777         case TRIM:
778         case LEFT:
779         case RIGHT:
780         case BOTH:
781         case EMPTY:
782         case MULTISET:
783         case SUBMULTISET:
784         case LEADING:
785         case TRAILING:
786         case CHAR_CS:
787         case NCHAR_CS:
788         case DBTIMEZONE:
789         case SESSIONTIMEZONE:
790         case AUTHENTICATED:
791         case LINK:
792         case SHARED:
793         case DIRECTORY:
794         case USER:
795         case IDENTIFIER:
796         case UNSIGNED_NUMERIC_LITERAL:
797         case CHARACTER_LITERAL:
798         case STRING_LITERAL:
799         case QUOTED_LITERAL:
800           ;
801           break;
802         default:
803           jj_la1[7] = jj_gen;
804           break label_4;
805         }
806         Statement();
807       }
808       switch (jj_nt.kind) {
809       case EXCEPTION:
810         ExceptionHandler();
811         break;
812       default:
813         jj_la1[8] = jj_gen;
814         ;
815       }
816       jj_consume_token(END);
817       switch (jj_nt.kind) {
818       case IDENTIFIER:
819         jj_consume_token(IDENTIFIER);
820         break;
821       default:
822         jj_la1[9] = jj_gen;
823         ;
824       }
825       jjtree.closeNodeScope(jjtn000, true);
826       jjtc000 = false;
827       {if (true) return jjtn000 ;}
828     } catch (Throwable jjte000) {
829       if (jjtc000) {
830         jjtree.clearNodeScope(jjtn000);
831         jjtc000 = false;
832       } else {
833         jjtree.popNode();
834       }
835       if (jjte000 instanceof RuntimeException) {
836         {if (true) throw (RuntimeException)jjte000;}
837       }
838       if (jjte000 instanceof ParseException) {
839         {if (true) throw (ParseException)jjte000;}
840       }
841       {if (true) throw (Error)jjte000;}
842     } finally {
843       if (jjtc000) {
844         jjtree.closeNodeScope(jjtn000, true);
845       }
846     }
847     throw new Error("Missing return statement in function");
848   }
849 
850   final public ASTPackageSpecification PackageSpecification() throws ParseException {
851  /*@bgen(jjtree) PackageSpecification */
852  ASTPackageSpecification jjtn000 = new ASTPackageSpecification(this, JJTPACKAGESPECIFICATION);
853  boolean jjtc000 = true;
854  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
855     try {
856       switch (jj_nt.kind) {
857       case CREATE:
858         jj_consume_token(CREATE);
859         switch (jj_nt.kind) {
860         case OR:
861           jj_consume_token(OR);
862           jj_consume_token(REPLACE);
863           break;
864         default:
865           jj_la1[10] = jj_gen;
866           ;
867         }
868         switch (jj_nt.kind) {
869         case EDITIONABLE:
870         case NONEDITIONABLE:
871           switch (jj_nt.kind) {
872           case EDITIONABLE:
873             jj_consume_token(EDITIONABLE);
874             break;
875           case NONEDITIONABLE:
876             jj_consume_token(NONEDITIONABLE);
877             break;
878           default:
879             jj_la1[11] = jj_gen;
880             jj_consume_token(-1);
881             throw new ParseException();
882           }
883           break;
884         default:
885           jj_la1[12] = jj_gen;
886           ;
887         }
888         break;
889       default:
890         jj_la1[13] = jj_gen;
891         ;
892       }
893       jj_consume_token(PACKAGE);
894       simpleNode = ObjectNameDeclaration();
895       label_5:
896       while (true) {
897         switch (jj_nt.kind) {
898         case AUTHID:
899         case ACCESSIBLE:
900           ;
901           break;
902         default:
903           jj_la1[14] = jj_gen;
904           break label_5;
905         }
906         switch (jj_nt.kind) {
907         case AUTHID:
908           jj_consume_token(AUTHID);
909           switch (jj_nt.kind) {
910           case CURRENT_USER:
911             jj_consume_token(CURRENT_USER);
912             break;
913           case DEFINER:
914             jj_consume_token(DEFINER);
915             break;
916           default:
917             jj_la1[15] = jj_gen;
918             jj_consume_token(-1);
919             throw new ParseException();
920           }
921           break;
922         case ACCESSIBLE:
923           AccessibleByClause();
924           break;
925         default:
926           jj_la1[16] = jj_gen;
927           jj_consume_token(-1);
928           throw new ParseException();
929         }
930       }
931       switch (jj_nt.kind) {
932       case WRAPPED:
933         WrappedObject();
934         break;
935       case AS:
936       case IS:
937         switch (jj_nt.kind) {
938         case IS:
939           jj_consume_token(IS);
940           break;
941         case AS:
942           jj_consume_token(AS);
943           break;
944         default:
945           jj_la1[17] = jj_gen;
946           jj_consume_token(-1);
947           throw new ParseException();
948         }
949         DeclarativeSection();
950         jj_consume_token(END);
951         switch (jj_nt.kind) {
952         case REPLACE:
953         case DEFINER:
954         case CURRENT_USER:
955         case SERIALLY_REUSABLE:
956         case RESTRICT_REFERENCES:
957         case EXCEPTION_INIT:
958         case AUTONOMOUS_TRANSACTION:
959         case LANGUAGE:
960         case ADD:
961         case AGGREGATE:
962         case ALL:
963         case ALTER:
964         case AND:
965         case ANY:
966         case ARRAY:
967         case AS:
968         case ASC:
969         case AT:
970         case ATTRIBUTE:
971         case AUTHID:
972         case AVG:
973         case BETWEEN:
974         case BINARY_INTEGER:
975         case BODY:
976         case BOOLEAN:
977         case BULK:
978         case BY:
979         case BYTE:
980         case CASCADE:
981         case CASE:
982         case CHAR:
983         case CHAR_BASE:
984         case CHECK:
985         case CLOSE:
986         case CLUSTER:
987         case COALESCE:
988         case COLLECT:
989         case COLUMN:
990         case COMMENT:
991         case COMMIT:
992         case COMPRESS:
993         case CONNECT:
994         case CONSTANT:
995         case CONSTRUCTOR:
996         case CONTINUE:
997         case CONVERT:
998         case CREATE:
999         case CURRENT:
1000         case CURRVAL:
1001         case CURSOR:
1002         case DATA:
1003         case DATE:
1004         case DAY:
1005         case DECLARE:
1006         case DECIMAL:
1007         case _DEFAULT:
1008         case DELETE:
1009         case DESC:
1010         case DISABLE:
1011         case DISTINCT:
1012         case DO:
1013         case DROP:
1014         case EDITIONABLE:
1015         case ELEMENT:
1016         case ELSE:
1017         case ELSIF:
1018         case ENABLE:
1019         case ESCAPE:
1020         case EXCEPT:
1021         case EXCEPTION:
1022         case EXCEPTIONS:
1023         case EXCLUSIVE:
1024         case EXECUTE:
1025         case EXISTS:
1026         case EXIT:
1027         case EXTERNAL:
1028         case EXTENDS:
1029         case EXTRACT:
1030         case FALSE:
1031         case FETCH:
1032         case FINAL:
1033         case FLOAT:
1034         case FOR:
1035         case FORALL:
1036         case FORCE:
1037         case FROM:
1038         case FUNCTION:
1039         case GLOBAL:
1040         case GOTO:
1041         case GROUP:
1042         case HASH:
1043         case HAVING:
1044         case HEAP:
1045         case HOUR:
1046         case IF:
1047         case IMMEDIATE:
1048         case IN:
1049         case INDEX:
1050         case INDICES:
1051         case INDEXTYPE:
1052         case INDICATOR:
1053         case INSERT:
1054         case INSTANTIABLE:
1055         case INTEGER:
1056         case INTERFACE:
1057         case INTERSECT:
1058         case INTERVAL:
1059         case INTO:
1060         case INVALIDATE:
1061         case IS:
1062         case ISOLATION:
1063         case JAVA:
1064         case LEVEL:
1065         case LIKE:
1066         case LIMIT:
1067         case LIMITED:
1068         case LOCK:
1069         case LONG:
1070         case LOOP:
1071         case MAP:
1072         case MAX:
1073         case MEMBER:
1074         case MERGE:
1075         case MIN:
1076         case MINUS:
1077         case MINUTE:
1078         case MLSLABEL:
1079         case MODIFY:
1080         case MOD:
1081         case MODE:
1082         case MONTH:
1083         case NATURAL:
1084         case NATURALN:
1085         case NEW:
1086         case NEXTVAL:
1087         case NO:
1088         case NOCOPY:
1089         case NONEDITIONABLE:
1090         case NOT:
1091         case NOWAIT:
1092         case NULL:
1093         case NULLIF:
1094         case NUMBER:
1095         case BFILE_BASE:
1096         case BLOB_BASE:
1097         case CLOB_BASE:
1098         case DATE_BASE:
1099         case NUMBER_BASE:
1100         case OBJECT:
1101         case OCIROWID:
1102         case OF:
1103         case OID:
1104         case ON:
1105         case OPAQUE:
1106         case OPEN:
1107         case OPERATOR:
1108         case OPTION:
1109         case OR:
1110         case ORDER:
1111         case ORGANIZATION:
1112         case OTHERS:
1113         case OUT:
1114         case OVERRIDING:
1115         case PACKAGE:
1116         case PARTITION:
1117         case PCTFREE:
1118         case PLS_INTEGER:
1119         case POSITIVE:
1120         case POSITIVEN:
1121         case PRESERVE:
1122         case PRIOR:
1123         case PROMPT:
1124         case PRIVATE:
1125         case PROCEDURE:
1126         case PUBLIC:
1127         case RAISE:
1128         case RANGE:
1129         case RAW:
1130         case REAL:
1131         case RECORD:
1132         case REF:
1133         case RELEASE:
1134         case RELIES_ON:
1135         case RENAME:
1136         case RESULT:
1137         case RETURN:
1138         case RETURNING:
1139         case REVERSE:
1140         case ROLLBACK:
1141         case ROW:
1142         case ROWS:
1143         case ROWID:
1144         case ROWNUM:
1145         case ROWTYPE:
1146         case SAVE:
1147         case SAVEPOINT:
1148         case SECOND:
1149         case SELECT:
1150         case SELF:
1151         case SEPARATE:
1152         case SET:
1153         case SHARE:
1154         case SMALLINT:
1155         case SPACE:
1156         case SQL:
1157         case SQLCODE:
1158         case SQLERRM:
1159         case START:
1160         case STATIC:
1161         case STDDEV:
1162         case SUBTYPE:
1163         case SUBSTITUTABLE:
1164         case SUCCESSFUL:
1165         case SUM:
1166         case SYNONYM:
1167         case SYSDATE:
1168         case SYS_REFCURSOR:
1169         case TABLE:
1170         case TEMPORARY:
1171         case THEN:
1172         case TIME:
1173         case TIMESTAMP:
1174         case TIMEZONE_REGION:
1175         case TIMEZONE_ABBR:
1176         case TIMEZONE_MINUTE:
1177         case TIMEZONE_HOUR:
1178         case TO:
1179         case TRANSACTION:
1180         case TRIGGER:
1181         case TRUE:
1182         case TYPE:
1183         case UI:
1184         case UNDER:
1185         case USING:
1186         case WHILE:
1187         case YES:
1188         case SHOW:
1189         case A:
1190         case UPDATE:
1191         case VARCHAR:
1192         case VARCHAR2:
1193         case DOUBLE:
1194         case DEC:
1195         case PRECISION:
1196         case INT:
1197         case NUMERIC:
1198         case SIGNTYPE:
1199         case NCHAR:
1200         case NVARCHAR2:
1201         case STRING:
1202         case UROWID:
1203         case VARRAY:
1204         case VARYING:
1205         case BFILE:
1206         case BLOB:
1207         case CLOB:
1208         case NCLOB:
1209         case YEAR:
1210         case LOCAL:
1211         case WITH:
1212         case ZONE:
1213         case CHARACTER:
1214         case AFTER:
1215         case BEFORE:
1216         case OLD:
1217         case PARENT:
1218         case ANALYZE:
1219         case ASSOCIATE:
1220         case AUDIT:
1221         case COMPOUND:
1222         case DATABASE:
1223         case CALL:
1224         case DDL:
1225         case DISASSOCIATE:
1226         case EACH:
1227         case FOLLOWS:
1228         case LOGOFF:
1229         case LOGON:
1230         case NESTED:
1231         case NOAUDIT:
1232         case SCHEMA:
1233         case SERVERERROR:
1234         case SHUTDOWN:
1235         case STARTUP:
1236         case STATEMENT:
1237         case STATISTICS:
1238         case SUSPEND:
1239         case TRUNCATE:
1240         case WRAPPED:
1241         case LIBRARY:
1242         case NAME:
1243         case STRUCT:
1244         case CONTEXT:
1245         case PARAMETERS:
1246         case LENGTH:
1247         case TDO:
1248         case MAXLEN:
1249         case CHARSETID:
1250         case CHARSETFORM:
1251         case ACCEPT:
1252         case ACCESSIBLE:
1253         case COPY:
1254         case DEFINE:
1255         case DISCONNECT:
1256         case HOST:
1257         case PRINT:
1258         case QUIT:
1259         case REMARK:
1260         case UNDEFINE:
1261         case VARIABLE:
1262         case WHENEVER:
1263         case ATTACH:
1264         case CAST:
1265         case TREAT:
1266         case TRIM:
1267         case LEFT:
1268         case RIGHT:
1269         case BOTH:
1270         case EMPTY:
1271         case MULTISET:
1272         case SUBMULTISET:
1273         case LEADING:
1274         case TRAILING:
1275         case CHAR_CS:
1276         case NCHAR_CS:
1277         case DBTIMEZONE:
1278         case SESSIONTIMEZONE:
1279         case AUTHENTICATED:
1280         case LINK:
1281         case SHARED:
1282         case DIRECTORY:
1283         case USER:
1284         case IDENTIFIER:
1285         case QUOTED_LITERAL:
1286         case SQLDATA_CLASS:
1287         case CUSTOMDATUM_CLASS:
1288         case ORADATA_CLASS:
1289         case JAVA_INTERFACE_CLASS:
1290           ID();
1291           break;
1292         default:
1293           jj_la1[18] = jj_gen;
1294           ;
1295         }
1296         jj_consume_token(4);
1297         break;
1298       default:
1299         jj_la1[19] = jj_gen;
1300         jj_consume_token(-1);
1301         throw new ParseException();
1302       }
1303         jjtree.closeNodeScope(jjtn000, true);
1304         jjtc000 = false;
1305         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
1306     } catch (Throwable jjte000) {
1307         if (jjtc000) {
1308           jjtree.clearNodeScope(jjtn000);
1309           jjtc000 = false;
1310         } else {
1311           jjtree.popNode();
1312         }
1313         if (jjte000 instanceof RuntimeException) {
1314           {if (true) throw (RuntimeException)jjte000;}
1315         }
1316         if (jjte000 instanceof ParseException) {
1317           {if (true) throw (ParseException)jjte000;}
1318         }
1319         {if (true) throw (Error)jjte000;}
1320     } finally {
1321         if (jjtc000) {
1322           jjtree.closeNodeScope(jjtn000, true);
1323         }
1324     }
1325     throw new Error("Missing return statement in function");
1326   }
1327 
1328   final public ASTPackageBody PackageBody() throws ParseException {
1329  /*@bgen(jjtree) PackageBody */
1330  ASTPackageBody jjtn000 = new ASTPackageBody(this, JJTPACKAGEBODY);
1331  boolean jjtc000 = true;
1332  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
1333     try {
1334       switch (jj_nt.kind) {
1335       case CREATE:
1336         jj_consume_token(CREATE);
1337         switch (jj_nt.kind) {
1338         case OR:
1339           jj_consume_token(OR);
1340           jj_consume_token(REPLACE);
1341           break;
1342         default:
1343           jj_la1[20] = jj_gen;
1344           ;
1345         }
1346         switch (jj_nt.kind) {
1347         case EDITIONABLE:
1348         case NONEDITIONABLE:
1349           switch (jj_nt.kind) {
1350           case EDITIONABLE:
1351             jj_consume_token(EDITIONABLE);
1352             break;
1353           case NONEDITIONABLE:
1354             jj_consume_token(NONEDITIONABLE);
1355             break;
1356           default:
1357             jj_la1[21] = jj_gen;
1358             jj_consume_token(-1);
1359             throw new ParseException();
1360           }
1361           break;
1362         default:
1363           jj_la1[22] = jj_gen;
1364           ;
1365         }
1366         break;
1367       default:
1368         jj_la1[23] = jj_gen;
1369         ;
1370       }
1371       switch (jj_nt.kind) {
1372       case PACKAGE:
1373         jj_consume_token(PACKAGE);
1374         break;
1375       case TYPE:
1376         jj_consume_token(TYPE);
1377         break;
1378       default:
1379         jj_la1[24] = jj_gen;
1380         jj_consume_token(-1);
1381         throw new ParseException();
1382       }
1383       jj_consume_token(BODY);
1384       simpleNode = ObjectNameDeclaration();
1385       switch (jj_nt.kind) {
1386       case WRAPPED:
1387         WrappedObject();
1388         break;
1389       case AS:
1390       case IS:
1391         switch (jj_nt.kind) {
1392         case IS:
1393           jj_consume_token(IS);
1394           break;
1395         case AS:
1396           jj_consume_token(AS);
1397           break;
1398         default:
1399           jj_la1[25] = jj_gen;
1400           jj_consume_token(-1);
1401           throw new ParseException();
1402         }
1403         DeclarativeSection();
1404         switch (jj_nt.kind) {
1405         case BEGIN:
1406           jj_consume_token(BEGIN);
1407           label_6:
1408           while (true) {
1409             switch (jj_nt.kind) {
1410             case 5:
1411             case 16:
1412             case 17:
1413             case 21:
1414             case REPLACE:
1415             case DEFINER:
1416             case CURRENT_USER:
1417             case LANGUAGE:
1418             case ADD:
1419             case AGGREGATE:
1420             case ARRAY:
1421             case AT:
1422             case ATTRIBUTE:
1423             case AUTHID:
1424             case BEGIN:
1425             case BODY:
1426             case BULK:
1427             case BYTE:
1428             case CASCADE:
1429             case CASE:
1430             case CLOSE:
1431             case COALESCE:
1432             case COLLECT:
1433             case COLUMN:
1434             case COMMENT:
1435             case COMMIT:
1436             case CONSTRUCTOR:
1437             case CONTINUE:
1438             case CONVERT:
1439             case CURRENT:
1440             case CURSOR:
1441             case DATA:
1442             case DATE:
1443             case DAY:
1444             case DECLARE:
1445             case DELETE:
1446             case DISABLE:
1447             case EDITIONABLE:
1448             case ELEMENT:
1449             case ENABLE:
1450             case ESCAPE:
1451             case EXCEPT:
1452             case EXCEPTIONS:
1453             case EXECUTE:
1454             case EXIT:
1455             case EXTERNAL:
1456             case EXTENDS:
1457             case EXTRACT:
1458             case FALSE:
1459             case FETCH:
1460             case FINAL:
1461             case FOR:
1462             case FORALL:
1463             case FORCE:
1464             case FUNCTION:
1465             case GLOBAL:
1466             case GOTO:
1467             case HASH:
1468             case HEAP:
1469             case HOUR:
1470             case IF:
1471             case IMMEDIATE:
1472             case INDICES:
1473             case INDEXTYPE:
1474             case INDICATOR:
1475             case INSERT:
1476             case INSTANTIABLE:
1477             case INTERVAL:
1478             case INVALIDATE:
1479             case ISOLATION:
1480             case JAVA:
1481             case LEVEL:
1482             case LIMIT:
1483             case LOCK:
1484             case LOOP:
1485             case MAP:
1486             case MAX:
1487             case MEMBER:
1488             case MERGE:
1489             case MIN:
1490             case MINUTE:
1491             case MLSLABEL:
1492             case MODIFY:
1493             case MOD:
1494             case MONTH:
1495             case NATURAL:
1496             case NEW:
1497             case NEW_DOT:
1498             case NO:
1499             case NONEDITIONABLE:
1500             case NOT:
1501             case NULL:
1502             case NULLIF:
1503             case OBJECT:
1504             case OID:
1505             case OPAQUE:
1506             case OPEN:
1507             case OPERATOR:
1508             case ORGANIZATION:
1509             case OTHERS:
1510             case OVERRIDING:
1511             case PACKAGE:
1512             case PARTITION:
1513             case PIPE:
1514             case PRESERVE:
1515             case PRIVATE:
1516             case PROCEDURE:
1517             case RAISE:
1518             case RANGE:
1519             case RAW:
1520             case REAL:
1521             case RECORD:
1522             case REF:
1523             case RELEASE:
1524             case RELIES_ON:
1525             case RENAME:
1526             case RESULT:
1527             case RETURN:
1528             case RETURNING:
1529             case REVERSE:
1530             case ROLLBACK:
1531             case ROW:
1532             case ROWS:
1533             case ROWID:
1534             case ROWNUM:
1535             case SAVE:
1536             case SAVEPOINT:
1537             case SECOND:
1538             case SELECT:
1539             case SELF:
1540             case SET:
1541             case SPACE:
1542             case SQL:
1543             case SQLCODE:
1544             case SQLERRM:
1545             case STATIC:
1546             case SUBTYPE:
1547             case SUBSTITUTABLE:
1548             case SUCCESSFUL:
1549             case SYSDATE:
1550             case SYS_REFCURSOR:
1551             case TEMPORARY:
1552             case TIME:
1553             case TIMESTAMP:
1554             case TIMEZONE_REGION:
1555             case TIMEZONE_ABBR:
1556             case TIMEZONE_MINUTE:
1557             case TIMEZONE_HOUR:
1558             case TRANSACTION:
1559             case TRUE:
1560             case TYPE:
1561             case UNDER:
1562             case USING:
1563             case WHILE:
1564             case YES:
1565             case SHOW:
1566             case A:
1567             case UPDATE:
1568             case DOUBLE:
1569             case DEC:
1570             case PRECISION:
1571             case INT:
1572             case NUMERIC:
1573             case NCHAR:
1574             case NVARCHAR2:
1575             case STRING:
1576             case UROWID:
1577             case VARRAY:
1578             case VARYING:
1579             case BFILE:
1580             case BLOB:
1581             case CLOB:
1582             case NCLOB:
1583             case YEAR:
1584             case LOCAL:
1585             case WITH:
1586             case ZONE:
1587             case CHARACTER:
1588             case AFTER:
1589             case BEFORE:
1590             case OLD:
1591             case PARENT:
1592             case CC_IF:
1593             case CC_ERROR:
1594             case ANALYZE:
1595             case ASSOCIATE:
1596             case AUDIT:
1597             case COMPOUND:
1598             case DATABASE:
1599             case CALL:
1600             case DDL:
1601             case DISASSOCIATE:
1602             case EACH:
1603             case FOLLOWS:
1604             case LOGOFF:
1605             case LOGON:
1606             case NESTED:
1607             case NOAUDIT:
1608             case SCHEMA:
1609             case SERVERERROR:
1610             case SHUTDOWN:
1611             case STARTUP:
1612             case STATEMENT:
1613             case STATISTICS:
1614             case SUSPEND:
1615             case TRUNCATE:
1616             case WRAPPED:
1617             case LIBRARY:
1618             case NAME:
1619             case STRUCT:
1620             case CONTEXT:
1621             case PARAMETERS:
1622             case LENGTH:
1623             case TDO:
1624             case MAXLEN:
1625             case CHARSETID:
1626             case CHARSETFORM:
1627             case ACCEPT:
1628             case ACCESSIBLE:
1629             case COPY:
1630             case DEFINE:
1631             case DISCONNECT:
1632             case HOST:
1633             case PRINT:
1634             case QUIT:
1635             case REMARK:
1636             case UNDEFINE:
1637             case VARIABLE:
1638             case WHENEVER:
1639             case ATTACH:
1640             case CAST:
1641             case TREAT:
1642             case TRIM:
1643             case LEFT:
1644             case RIGHT:
1645             case BOTH:
1646             case EMPTY:
1647             case MULTISET:
1648             case SUBMULTISET:
1649             case LEADING:
1650             case TRAILING:
1651             case CHAR_CS:
1652             case NCHAR_CS:
1653             case DBTIMEZONE:
1654             case SESSIONTIMEZONE:
1655             case AUTHENTICATED:
1656             case LINK:
1657             case SHARED:
1658             case DIRECTORY:
1659             case USER:
1660             case IDENTIFIER:
1661             case UNSIGNED_NUMERIC_LITERAL:
1662             case CHARACTER_LITERAL:
1663             case STRING_LITERAL:
1664             case QUOTED_LITERAL:
1665               ;
1666               break;
1667             default:
1668               jj_la1[26] = jj_gen;
1669               break label_6;
1670             }
1671             Statement();
1672           }
1673           switch (jj_nt.kind) {
1674           case EXCEPTION:
1675             ExceptionHandler();
1676             break;
1677           default:
1678             jj_la1[27] = jj_gen;
1679             ;
1680           }
1681           break;
1682         default:
1683           jj_la1[28] = jj_gen;
1684           ;
1685         }
1686         jj_consume_token(END);
1687         switch (jj_nt.kind) {
1688         case REPLACE:
1689         case DEFINER:
1690         case CURRENT_USER:
1691         case SERIALLY_REUSABLE:
1692         case RESTRICT_REFERENCES:
1693         case EXCEPTION_INIT:
1694         case AUTONOMOUS_TRANSACTION:
1695         case LANGUAGE:
1696         case ADD:
1697         case AGGREGATE:
1698         case ALL:
1699         case ALTER:
1700         case AND:
1701         case ANY:
1702         case ARRAY:
1703         case AS:
1704         case ASC:
1705         case AT:
1706         case ATTRIBUTE:
1707         case AUTHID:
1708         case AVG:
1709         case BETWEEN:
1710         case BINARY_INTEGER:
1711         case BODY:
1712         case BOOLEAN:
1713         case BULK:
1714         case BY:
1715         case BYTE:
1716         case CASCADE:
1717         case CASE:
1718         case CHAR:
1719         case CHAR_BASE:
1720         case CHECK:
1721         case CLOSE:
1722         case CLUSTER:
1723         case COALESCE:
1724         case COLLECT:
1725         case COLUMN:
1726         case COMMENT:
1727         case COMMIT:
1728         case COMPRESS:
1729         case CONNECT:
1730         case CONSTANT:
1731         case CONSTRUCTOR:
1732         case CONTINUE:
1733         case CONVERT:
1734         case CREATE:
1735         case CURRENT:
1736         case CURRVAL:
1737         case CURSOR:
1738         case DATA:
1739         case DATE:
1740         case DAY:
1741         case DECLARE:
1742         case DECIMAL:
1743         case _DEFAULT:
1744         case DELETE:
1745         case DESC:
1746         case DISABLE:
1747         case DISTINCT:
1748         case DO:
1749         case DROP:
1750         case EDITIONABLE:
1751         case ELEMENT:
1752         case ELSE:
1753         case ELSIF:
1754         case ENABLE:
1755         case ESCAPE:
1756         case EXCEPT:
1757         case EXCEPTION:
1758         case EXCEPTIONS:
1759         case EXCLUSIVE:
1760         case EXECUTE:
1761         case EXISTS:
1762         case EXIT:
1763         case EXTERNAL:
1764         case EXTENDS:
1765         case EXTRACT:
1766         case FALSE:
1767         case FETCH:
1768         case FINAL:
1769         case FLOAT:
1770         case FOR:
1771         case FORALL:
1772         case FORCE:
1773         case FROM:
1774         case FUNCTION:
1775         case GLOBAL:
1776         case GOTO:
1777         case GROUP:
1778         case HASH:
1779         case HAVING:
1780         case HEAP:
1781         case HOUR:
1782         case IF:
1783         case IMMEDIATE:
1784         case IN:
1785         case INDEX:
1786         case INDICES:
1787         case INDEXTYPE:
1788         case INDICATOR:
1789         case INSERT:
1790         case INSTANTIABLE:
1791         case INTEGER:
1792         case INTERFACE:
1793         case INTERSECT:
1794         case INTERVAL:
1795         case INTO:
1796         case INVALIDATE:
1797         case IS:
1798         case ISOLATION:
1799         case JAVA:
1800         case LEVEL:
1801         case LIKE:
1802         case LIMIT:
1803         case LIMITED:
1804         case LOCK:
1805         case LONG:
1806         case LOOP:
1807         case MAP:
1808         case MAX:
1809         case MEMBER:
1810         case MERGE:
1811         case MIN:
1812         case MINUS:
1813         case MINUTE:
1814         case MLSLABEL:
1815         case MODIFY:
1816         case MOD:
1817         case MODE:
1818         case MONTH:
1819         case NATURAL:
1820         case NATURALN:
1821         case NEW:
1822         case NEXTVAL:
1823         case NO:
1824         case NOCOPY:
1825         case NONEDITIONABLE:
1826         case NOT:
1827         case NOWAIT:
1828         case NULL:
1829         case NULLIF:
1830         case NUMBER:
1831         case BFILE_BASE:
1832         case BLOB_BASE:
1833         case CLOB_BASE:
1834         case DATE_BASE:
1835         case NUMBER_BASE:
1836         case OBJECT:
1837         case OCIROWID:
1838         case OF:
1839         case OID:
1840         case ON:
1841         case OPAQUE:
1842         case OPEN:
1843         case OPERATOR:
1844         case OPTION:
1845         case OR:
1846         case ORDER:
1847         case ORGANIZATION:
1848         case OTHERS:
1849         case OUT:
1850         case OVERRIDING:
1851         case PACKAGE:
1852         case PARTITION:
1853         case PCTFREE:
1854         case PLS_INTEGER:
1855         case POSITIVE:
1856         case POSITIVEN:
1857         case PRESERVE:
1858         case PRIOR:
1859         case PROMPT:
1860         case PRIVATE:
1861         case PROCEDURE:
1862         case PUBLIC:
1863         case RAISE:
1864         case RANGE:
1865         case RAW:
1866         case REAL:
1867         case RECORD:
1868         case REF:
1869         case RELEASE:
1870         case RELIES_ON:
1871         case RENAME:
1872         case RESULT:
1873         case RETURN:
1874         case RETURNING:
1875         case REVERSE:
1876         case ROLLBACK:
1877         case ROW:
1878         case ROWS:
1879         case ROWID:
1880         case ROWNUM:
1881         case ROWTYPE:
1882         case SAVE:
1883         case SAVEPOINT:
1884         case SECOND:
1885         case SELECT:
1886         case SELF:
1887         case SEPARATE:
1888         case SET:
1889         case SHARE:
1890         case SMALLINT:
1891         case SPACE:
1892         case SQL:
1893         case SQLCODE:
1894         case SQLERRM:
1895         case START:
1896         case STATIC:
1897         case STDDEV:
1898         case SUBTYPE:
1899         case SUBSTITUTABLE:
1900         case SUCCESSFUL:
1901         case SUM:
1902         case SYNONYM:
1903         case SYSDATE:
1904         case SYS_REFCURSOR:
1905         case TABLE:
1906         case TEMPORARY:
1907         case THEN:
1908         case TIME:
1909         case TIMESTAMP:
1910         case TIMEZONE_REGION:
1911         case TIMEZONE_ABBR:
1912         case TIMEZONE_MINUTE:
1913         case TIMEZONE_HOUR:
1914         case TO:
1915         case TRANSACTION:
1916         case TRIGGER:
1917         case TRUE:
1918         case TYPE:
1919         case UI:
1920         case UNDER:
1921         case USING:
1922         case WHILE:
1923         case YES:
1924         case SHOW:
1925         case A:
1926         case UPDATE:
1927         case VARCHAR:
1928         case VARCHAR2:
1929         case DOUBLE:
1930         case DEC:
1931         case PRECISION:
1932         case INT:
1933         case NUMERIC:
1934         case SIGNTYPE:
1935         case NCHAR:
1936         case NVARCHAR2:
1937         case STRING:
1938         case UROWID:
1939         case VARRAY:
1940         case VARYING:
1941         case BFILE:
1942         case BLOB:
1943         case CLOB:
1944         case NCLOB:
1945         case YEAR:
1946         case LOCAL:
1947         case WITH:
1948         case ZONE:
1949         case CHARACTER:
1950         case AFTER:
1951         case BEFORE:
1952         case OLD:
1953         case PARENT:
1954         case ANALYZE:
1955         case ASSOCIATE:
1956         case AUDIT:
1957         case COMPOUND:
1958         case DATABASE:
1959         case CALL:
1960         case DDL:
1961         case DISASSOCIATE:
1962         case EACH:
1963         case FOLLOWS:
1964         case LOGOFF:
1965         case LOGON:
1966         case NESTED:
1967         case NOAUDIT:
1968         case SCHEMA:
1969         case SERVERERROR:
1970         case SHUTDOWN:
1971         case STARTUP:
1972         case STATEMENT:
1973         case STATISTICS:
1974         case SUSPEND:
1975         case TRUNCATE:
1976         case WRAPPED:
1977         case LIBRARY:
1978         case NAME:
1979         case STRUCT:
1980         case CONTEXT:
1981         case PARAMETERS:
1982         case LENGTH:
1983         case TDO:
1984         case MAXLEN:
1985         case CHARSETID:
1986         case CHARSETFORM:
1987         case ACCEPT:
1988         case ACCESSIBLE:
1989         case COPY:
1990         case DEFINE:
1991         case DISCONNECT:
1992         case HOST:
1993         case PRINT:
1994         case QUIT:
1995         case REMARK:
1996         case UNDEFINE:
1997         case VARIABLE:
1998         case WHENEVER:
1999         case ATTACH:
2000         case CAST:
2001         case TREAT:
2002         case TRIM:
2003         case LEFT:
2004         case RIGHT:
2005         case BOTH:
2006         case EMPTY:
2007         case MULTISET:
2008         case SUBMULTISET:
2009         case LEADING:
2010         case TRAILING:
2011         case CHAR_CS:
2012         case NCHAR_CS:
2013         case DBTIMEZONE:
2014         case SESSIONTIMEZONE:
2015         case AUTHENTICATED:
2016         case LINK:
2017         case SHARED:
2018         case DIRECTORY:
2019         case USER:
2020         case IDENTIFIER:
2021         case QUOTED_LITERAL:
2022         case SQLDATA_CLASS:
2023         case CUSTOMDATUM_CLASS:
2024         case ORADATA_CLASS:
2025         case JAVA_INTERFACE_CLASS:
2026           ID();
2027           break;
2028         default:
2029           jj_la1[29] = jj_gen;
2030           ;
2031         }
2032         jj_consume_token(4);
2033         break;
2034       default:
2035         jj_la1[30] = jj_gen;
2036         jj_consume_token(-1);
2037         throw new ParseException();
2038       }
2039       jjtree.closeNodeScope(jjtn000, true);
2040       jjtc000 = false;
2041       jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
2042     } catch (Throwable jjte000) {
2043       if (jjtc000) {
2044         jjtree.clearNodeScope(jjtn000);
2045         jjtc000 = false;
2046       } else {
2047         jjtree.popNode();
2048       }
2049       if (jjte000 instanceof RuntimeException) {
2050         {if (true) throw (RuntimeException)jjte000;}
2051       }
2052       if (jjte000 instanceof ParseException) {
2053         {if (true) throw (ParseException)jjte000;}
2054       }
2055       {if (true) throw (Error)jjte000;}
2056     } finally {
2057       if (jjtc000) {
2058         jjtree.closeNodeScope(jjtn000, true);
2059       }
2060     }
2061     throw new Error("Missing return statement in function");
2062   }
2063 
2064   final public ASTDeclarativeUnit DeclarativeUnit() throws ParseException {
2065  /*@bgen(jjtree) DeclarativeUnit */
2066   ASTDeclarativeUnit jjtn000 = new ASTDeclarativeUnit(this, JJTDECLARATIVEUNIT);
2067   boolean jjtc000 = true;
2068   jjtree.openNodeScope(jjtn000);
2069     try {
2070       switch (jj_nt.kind) {
2071       case PRAGMA:
2072         Pragma();
2073         break;
2074       default:
2075         jj_la1[31] = jj_gen;
2076         if (jj_2_16(2)) {
2077           ExceptionDeclaration();
2078         } else if (jj_2_17(2147483647)) {
2079           SubTypeDefinition();
2080         } else if (jj_2_18(2147483647)) {
2081           ProgramUnit();
2082         } else if (jj_2_19(4)) {
2083           VariableOrConstantDeclaration();
2084         } else if (jj_2_20(2)) {
2085           CursorSpecification();
2086         } else {
2087           switch (jj_nt.kind) {
2088           case CURSOR:
2089             CursorBody();
2090             break;
2091           case IDENTIFIER:
2092             CollectionDeclaration();
2093             break;
2094           case CONSTRUCTOR:
2095           case CREATE:
2096           case FINAL:
2097           case FUNCTION:
2098           case INSTANTIABLE:
2099           case MAP:
2100           case MEMBER:
2101           case NOT:
2102           case ORDER:
2103           case OVERRIDING:
2104           case PROCEDURE:
2105           case STATIC:
2106             MethodDeclaration();
2107             break;
2108           case CC_IF:
2109             CompilationDeclarationFragment();
2110             break;
2111           default:
2112             jj_la1[32] = jj_gen;
2113             jj_consume_token(-1);
2114             throw new ParseException();
2115           }
2116         }
2117       }
2118       jjtree.closeNodeScope(jjtn000, true);
2119       jjtc000 = false;
2120       {if (true) return jjtn000 ;}
2121     } catch (Throwable jjte000) {
2122       if (jjtc000) {
2123         jjtree.clearNodeScope(jjtn000);
2124         jjtc000 = false;
2125       } else {
2126         jjtree.popNode();
2127       }
2128       if (jjte000 instanceof RuntimeException) {
2129         {if (true) throw (RuntimeException)jjte000;}
2130       }
2131       if (jjte000 instanceof ParseException) {
2132         {if (true) throw (ParseException)jjte000;}
2133       }
2134       {if (true) throw (Error)jjte000;}
2135     } finally {
2136       if (jjtc000) {
2137         jjtree.closeNodeScope(jjtn000, true);
2138       }
2139     }
2140     throw new Error("Missing return statement in function");
2141   }
2142 
2143   final public ASTDeclarativeSection DeclarativeSection() throws ParseException {
2144  /*@bgen(jjtree) DeclarativeSection */
2145   ASTDeclarativeSection jjtn000 = new ASTDeclarativeSection(this, JJTDECLARATIVESECTION);
2146   boolean jjtc000 = true;
2147   jjtree.openNodeScope(jjtn000);
2148     try {
2149       label_7:
2150       while (true) {
2151         switch (jj_nt.kind) {
2152         case REPLACE:
2153         case DEFINER:
2154         case CURRENT_USER:
2155         case SERIALLY_REUSABLE:
2156         case RESTRICT_REFERENCES:
2157         case EXCEPTION_INIT:
2158         case AUTONOMOUS_TRANSACTION:
2159         case LANGUAGE:
2160         case ADD:
2161         case AGGREGATE:
2162         case ALL:
2163         case ALTER:
2164         case AND:
2165         case ANY:
2166         case ARRAY:
2167         case AS:
2168         case ASC:
2169         case AT:
2170         case ATTRIBUTE:
2171         case AUTHID:
2172         case AVG:
2173         case BETWEEN:
2174         case BINARY_INTEGER:
2175         case BODY:
2176         case BOOLEAN:
2177         case BULK:
2178         case BY:
2179         case BYTE:
2180         case CASCADE:
2181         case CASE:
2182         case CHAR:
2183         case CHAR_BASE:
2184         case CHECK:
2185         case CLOSE:
2186         case CLUSTER:
2187         case COALESCE:
2188         case COLLECT:
2189         case COLUMN:
2190         case COMMENT:
2191         case COMMIT:
2192         case COMPRESS:
2193         case CONNECT:
2194         case CONSTANT:
2195         case CONSTRUCTOR:
2196         case CONTINUE:
2197         case CONVERT:
2198         case CREATE:
2199         case CURRENT:
2200         case CURRVAL:
2201         case CURSOR:
2202         case DATA:
2203         case DATE:
2204         case DAY:
2205         case DECLARE:
2206         case DECIMAL:
2207         case _DEFAULT:
2208         case DELETE:
2209         case DESC:
2210         case DISABLE:
2211         case DISTINCT:
2212         case DO:
2213         case DROP:
2214         case EDITIONABLE:
2215         case ELEMENT:
2216         case ELSE:
2217         case ELSIF:
2218         case ENABLE:
2219         case ESCAPE:
2220         case EXCEPT:
2221         case EXCEPTION:
2222         case EXCEPTIONS:
2223         case EXCLUSIVE:
2224         case EXECUTE:
2225         case EXISTS:
2226         case EXIT:
2227         case EXTERNAL:
2228         case EXTENDS:
2229         case EXTRACT:
2230         case FALSE:
2231         case FETCH:
2232         case FINAL:
2233         case FLOAT:
2234         case FOR:
2235         case FORALL:
2236         case FORCE:
2237         case FROM:
2238         case FUNCTION:
2239         case GLOBAL:
2240         case GOTO:
2241         case GROUP:
2242         case HASH:
2243         case HAVING:
2244         case HEAP:
2245         case HOUR:
2246         case IF:
2247         case IMMEDIATE:
2248         case IN:
2249         case INDEX:
2250         case INDICES:
2251         case INDEXTYPE:
2252         case INDICATOR:
2253         case INSERT:
2254         case INSTANTIABLE:
2255         case INTEGER:
2256         case INTERFACE:
2257         case INTERSECT:
2258         case INTERVAL:
2259         case INTO:
2260         case INVALIDATE:
2261         case IS:
2262         case ISOLATION:
2263         case JAVA:
2264         case LEVEL:
2265         case LIKE:
2266         case LIMIT:
2267         case LIMITED:
2268         case LOCK:
2269         case LONG:
2270         case LOOP:
2271         case MAP:
2272         case MAX:
2273         case MEMBER:
2274         case MERGE:
2275         case MIN:
2276         case MINUS:
2277         case MINUTE:
2278         case MLSLABEL:
2279         case MODIFY:
2280         case MOD:
2281         case MODE:
2282         case MONTH:
2283         case NATURAL:
2284         case NATURALN:
2285         case NEW:
2286         case NEXTVAL:
2287         case NO:
2288         case NOCOPY:
2289         case NONEDITIONABLE:
2290         case NOT:
2291         case NOWAIT:
2292         case NULL:
2293         case NULLIF:
2294         case NUMBER:
2295         case BFILE_BASE:
2296         case BLOB_BASE:
2297         case CLOB_BASE:
2298         case DATE_BASE:
2299         case NUMBER_BASE:
2300         case OBJECT:
2301         case OCIROWID:
2302         case OF:
2303         case OID:
2304         case ON:
2305         case OPAQUE:
2306         case OPEN:
2307         case OPERATOR:
2308         case OPTION:
2309         case OR:
2310         case ORDER:
2311         case ORGANIZATION:
2312         case OTHERS:
2313         case OUT:
2314         case OVERRIDING:
2315         case PACKAGE:
2316         case PARTITION:
2317         case PCTFREE:
2318         case PLS_INTEGER:
2319         case POSITIVE:
2320         case POSITIVEN:
2321         case PRAGMA:
2322         case PRESERVE:
2323         case PRIOR:
2324         case PROMPT:
2325         case PRIVATE:
2326         case PROCEDURE:
2327         case PUBLIC:
2328         case RAISE:
2329         case RANGE:
2330         case RAW:
2331         case REAL:
2332         case RECORD:
2333         case REF:
2334         case RELEASE:
2335         case RELIES_ON:
2336         case RENAME:
2337         case RESULT:
2338         case RETURN:
2339         case RETURNING:
2340         case REVERSE:
2341         case ROLLBACK:
2342         case ROW:
2343         case ROWS:
2344         case ROWID:
2345         case ROWNUM:
2346         case ROWTYPE:
2347         case SAVE:
2348         case SAVEPOINT:
2349         case SECOND:
2350         case SELECT:
2351         case SELF:
2352         case SEPARATE:
2353         case SET:
2354         case SHARE:
2355         case SMALLINT:
2356         case SPACE:
2357         case SQL:
2358         case SQLCODE:
2359         case SQLERRM:
2360         case START:
2361         case STATIC:
2362         case STDDEV:
2363         case SUBTYPE:
2364         case SUBSTITUTABLE:
2365         case SUCCESSFUL:
2366         case SUM:
2367         case SYNONYM:
2368         case SYSDATE:
2369         case SYS_REFCURSOR:
2370         case TABLE:
2371         case TEMPORARY:
2372         case THEN:
2373         case TIME:
2374         case TIMESTAMP:
2375         case TIMEZONE_REGION:
2376         case TIMEZONE_ABBR:
2377         case TIMEZONE_MINUTE:
2378         case TIMEZONE_HOUR:
2379         case TO:
2380         case TRANSACTION:
2381         case TRIGGER:
2382         case TRUE:
2383         case TYPE:
2384         case UI:
2385         case UNDER:
2386         case USING:
2387         case WHILE:
2388         case YES:
2389         case SHOW:
2390         case A:
2391         case UPDATE:
2392         case VARCHAR:
2393         case VARCHAR2:
2394         case DOUBLE:
2395         case DEC:
2396         case PRECISION:
2397         case INT:
2398         case NUMERIC:
2399         case SIGNTYPE:
2400         case NCHAR:
2401         case NVARCHAR2:
2402         case STRING:
2403         case UROWID:
2404         case VARRAY:
2405         case VARYING:
2406         case BFILE:
2407         case BLOB:
2408         case CLOB:
2409         case NCLOB:
2410         case YEAR:
2411         case LOCAL:
2412         case WITH:
2413         case ZONE:
2414         case CHARACTER:
2415         case AFTER:
2416         case BEFORE:
2417         case OLD:
2418         case PARENT:
2419         case CC_IF:
2420         case ANALYZE:
2421         case ASSOCIATE:
2422         case AUDIT:
2423         case COMPOUND:
2424         case DATABASE:
2425         case CALL:
2426         case DDL:
2427         case DISASSOCIATE:
2428         case EACH:
2429         case FOLLOWS:
2430         case LOGOFF:
2431         case LOGON:
2432         case NESTED:
2433         case NOAUDIT:
2434         case SCHEMA:
2435         case SERVERERROR:
2436         case SHUTDOWN:
2437         case STARTUP:
2438         case STATEMENT:
2439         case STATISTICS:
2440         case SUSPEND:
2441         case TRUNCATE:
2442         case WRAPPED:
2443         case LIBRARY:
2444         case NAME:
2445         case STRUCT:
2446         case CONTEXT:
2447         case PARAMETERS:
2448         case LENGTH:
2449         case TDO:
2450         case MAXLEN:
2451         case CHARSETID:
2452         case CHARSETFORM:
2453         case ACCEPT:
2454         case ACCESSIBLE:
2455         case COPY:
2456         case DEFINE:
2457         case DISCONNECT:
2458         case HOST:
2459         case PRINT:
2460         case QUIT:
2461         case REMARK:
2462         case UNDEFINE:
2463         case VARIABLE:
2464         case WHENEVER:
2465         case ATTACH:
2466         case CAST:
2467         case TREAT:
2468         case TRIM:
2469         case LEFT:
2470         case RIGHT:
2471         case BOTH:
2472         case EMPTY:
2473         case MULTISET:
2474         case SUBMULTISET:
2475         case LEADING:
2476         case TRAILING:
2477         case CHAR_CS:
2478         case NCHAR_CS:
2479         case DBTIMEZONE:
2480         case SESSIONTIMEZONE:
2481         case AUTHENTICATED:
2482         case LINK:
2483         case SHARED:
2484         case DIRECTORY:
2485         case USER:
2486         case IDENTIFIER:
2487         case QUOTED_LITERAL:
2488         case SQLDATA_CLASS:
2489         case CUSTOMDATUM_CLASS:
2490         case ORADATA_CLASS:
2491         case JAVA_INTERFACE_CLASS:
2492           ;
2493           break;
2494         default:
2495           jj_la1[33] = jj_gen;
2496           break label_7;
2497         }
2498         DeclarativeUnit();
2499       }
2500         jjtree.closeNodeScope(jjtn000, true);
2501         jjtc000 = false;
2502         {if (true) return jjtn000 ;}
2503     } catch (Throwable jjte000) {
2504           if (jjtc000) {
2505             jjtree.clearNodeScope(jjtn000);
2506             jjtc000 = false;
2507           } else {
2508             jjtree.popNode();
2509           }
2510           if (jjte000 instanceof RuntimeException) {
2511             {if (true) throw (RuntimeException)jjte000;}
2512           }
2513           if (jjte000 instanceof ParseException) {
2514             {if (true) throw (ParseException)jjte000;}
2515           }
2516           {if (true) throw (Error)jjte000;}
2517     } finally {
2518           if (jjtc000) {
2519             jjtree.closeNodeScope(jjtn000, true);
2520           }
2521     }
2522     throw new Error("Missing return statement in function");
2523   }
2524 
2525   final public ASTCompilationDeclarationFragment CompilationDeclarationFragment() throws ParseException {
2526  /*@bgen(jjtree) CompilationDeclarationFragment */
2527   ASTCompilationDeclarationFragment jjtn000 = new ASTCompilationDeclarationFragment(this, JJTCOMPILATIONDECLARATIONFRAGMENT);
2528   boolean jjtc000 = true;
2529   jjtree.openNodeScope(jjtn000);
2530     try {
2531       jj_consume_token(CC_IF);
2532       ConditionalOrExpression();
2533       jj_consume_token(CC_THEN);
2534       label_8:
2535       while (true) {
2536         switch (jj_nt.kind) {
2537         case REPLACE:
2538         case DEFINER:
2539         case CURRENT_USER:
2540         case SERIALLY_REUSABLE:
2541         case RESTRICT_REFERENCES:
2542         case EXCEPTION_INIT:
2543         case AUTONOMOUS_TRANSACTION:
2544         case LANGUAGE:
2545         case ADD:
2546         case AGGREGATE:
2547         case ALL:
2548         case ALTER:
2549         case AND:
2550         case ANY:
2551         case ARRAY:
2552         case AS:
2553         case ASC:
2554         case AT:
2555         case ATTRIBUTE:
2556         case AUTHID:
2557         case AVG:
2558         case BETWEEN:
2559         case BINARY_INTEGER:
2560         case BODY:
2561         case BOOLEAN:
2562         case BULK:
2563         case BY:
2564         case BYTE:
2565         case CASCADE:
2566         case CASE:
2567         case CHAR:
2568         case CHAR_BASE:
2569         case CHECK:
2570         case CLOSE:
2571         case CLUSTER:
2572         case COALESCE:
2573         case COLLECT:
2574         case COLUMN:
2575         case COMMENT:
2576         case COMMIT:
2577         case COMPRESS:
2578         case CONNECT:
2579         case CONSTANT:
2580         case CONSTRUCTOR:
2581         case CONTINUE:
2582         case CONVERT:
2583         case CREATE:
2584         case CURRENT:
2585         case CURRVAL:
2586         case CURSOR:
2587         case DATA:
2588         case DATE:
2589         case DAY:
2590         case DECLARE:
2591         case DECIMAL:
2592         case _DEFAULT:
2593         case DELETE:
2594         case DESC:
2595         case DISABLE:
2596         case DISTINCT:
2597         case DO:
2598         case DROP:
2599         case EDITIONABLE:
2600         case ELEMENT:
2601         case ELSE:
2602         case ELSIF:
2603         case ENABLE:
2604         case ESCAPE:
2605         case EXCEPT:
2606         case EXCEPTION:
2607         case EXCEPTIONS:
2608         case EXCLUSIVE:
2609         case EXECUTE:
2610         case EXISTS:
2611         case EXIT:
2612         case EXTERNAL:
2613         case EXTENDS:
2614         case EXTRACT:
2615         case FALSE:
2616         case FETCH:
2617         case FINAL:
2618         case FLOAT:
2619         case FOR:
2620         case FORALL:
2621         case FORCE:
2622         case FROM:
2623         case FUNCTION:
2624         case GLOBAL:
2625         case GOTO:
2626         case GROUP:
2627         case HASH:
2628         case HAVING:
2629         case HEAP:
2630         case HOUR:
2631         case IF:
2632         case IMMEDIATE:
2633         case IN:
2634         case INDEX:
2635         case INDICES:
2636         case INDEXTYPE:
2637         case INDICATOR:
2638         case INSERT:
2639         case INSTANTIABLE:
2640         case INTEGER:
2641         case INTERFACE:
2642         case INTERSECT:
2643         case INTERVAL:
2644         case INTO:
2645         case INVALIDATE:
2646         case IS:
2647         case ISOLATION:
2648         case JAVA:
2649         case LEVEL:
2650         case LIKE:
2651         case LIMIT:
2652         case LIMITED:
2653         case LOCK:
2654         case LONG:
2655         case LOOP:
2656         case MAP:
2657         case MAX:
2658         case MEMBER:
2659         case MERGE:
2660         case MIN:
2661         case MINUS:
2662         case MINUTE:
2663         case MLSLABEL:
2664         case MODIFY:
2665         case MOD:
2666         case MODE:
2667         case MONTH:
2668         case NATURAL:
2669         case NATURALN:
2670         case NEW:
2671         case NEXTVAL:
2672         case NO:
2673         case NOCOPY:
2674         case NONEDITIONABLE:
2675         case NOT:
2676         case NOWAIT:
2677         case NULL:
2678         case NULLIF:
2679         case NUMBER:
2680         case BFILE_BASE:
2681         case BLOB_BASE:
2682         case CLOB_BASE:
2683         case DATE_BASE:
2684         case NUMBER_BASE:
2685         case OBJECT:
2686         case OCIROWID:
2687         case OF:
2688         case OID:
2689         case ON:
2690         case OPAQUE:
2691         case OPEN:
2692         case OPERATOR:
2693         case OPTION:
2694         case OR:
2695         case ORDER:
2696         case ORGANIZATION:
2697         case OTHERS:
2698         case OUT:
2699         case OVERRIDING:
2700         case PACKAGE:
2701         case PARTITION:
2702         case PCTFREE:
2703         case PLS_INTEGER:
2704         case POSITIVE:
2705         case POSITIVEN:
2706         case PRAGMA:
2707         case PRESERVE:
2708         case PRIOR:
2709         case PROMPT:
2710         case PRIVATE:
2711         case PROCEDURE:
2712         case PUBLIC:
2713         case RAISE:
2714         case RANGE:
2715         case RAW:
2716         case REAL:
2717         case RECORD:
2718         case REF:
2719         case RELEASE:
2720         case RELIES_ON:
2721         case RENAME:
2722         case RESULT:
2723         case RETURN:
2724         case RETURNING:
2725         case REVERSE:
2726         case ROLLBACK:
2727         case ROW:
2728         case ROWS:
2729         case ROWID:
2730         case ROWNUM:
2731         case ROWTYPE:
2732         case SAVE:
2733         case SAVEPOINT:
2734         case SECOND:
2735         case SELECT:
2736         case SELF:
2737         case SEPARATE:
2738         case SET:
2739         case SHARE:
2740         case SMALLINT:
2741         case SPACE:
2742         case SQL:
2743         case SQLCODE:
2744         case SQLERRM:
2745         case START:
2746         case STATIC:
2747         case STDDEV:
2748         case SUBTYPE:
2749         case SUBSTITUTABLE:
2750         case SUCCESSFUL:
2751         case SUM:
2752         case SYNONYM:
2753         case SYSDATE:
2754         case SYS_REFCURSOR:
2755         case TABLE:
2756         case TEMPORARY:
2757         case THEN:
2758         case TIME:
2759         case TIMESTAMP:
2760         case TIMEZONE_REGION:
2761         case TIMEZONE_ABBR:
2762         case TIMEZONE_MINUTE:
2763         case TIMEZONE_HOUR:
2764         case TO:
2765         case TRANSACTION:
2766         case TRIGGER:
2767         case TRUE:
2768         case TYPE:
2769         case UI:
2770         case UNDER:
2771         case USING:
2772         case WHILE:
2773         case YES:
2774         case SHOW:
2775         case A:
2776         case UPDATE:
2777         case VARCHAR:
2778         case VARCHAR2:
2779         case DOUBLE:
2780         case DEC:
2781         case PRECISION:
2782         case INT:
2783         case NUMERIC:
2784         case SIGNTYPE:
2785         case NCHAR:
2786         case NVARCHAR2:
2787         case STRING:
2788         case UROWID:
2789         case VARRAY:
2790         case VARYING:
2791         case BFILE:
2792         case BLOB:
2793         case CLOB:
2794         case NCLOB:
2795         case YEAR:
2796         case LOCAL:
2797         case WITH:
2798         case ZONE:
2799         case CHARACTER:
2800         case AFTER:
2801         case BEFORE:
2802         case OLD:
2803         case PARENT:
2804         case CC_IF:
2805         case CC_ERROR:
2806         case ANALYZE:
2807         case ASSOCIATE:
2808         case AUDIT:
2809         case COMPOUND:
2810         case DATABASE:
2811         case CALL:
2812         case DDL:
2813         case DISASSOCIATE:
2814         case EACH:
2815         case FOLLOWS:
2816         case LOGOFF:
2817         case LOGON:
2818         case NESTED:
2819         case NOAUDIT:
2820         case SCHEMA:
2821         case SERVERERROR:
2822         case SHUTDOWN:
2823         case STARTUP:
2824         case STATEMENT:
2825         case STATISTICS:
2826         case SUSPEND:
2827         case TRUNCATE:
2828         case WRAPPED:
2829         case LIBRARY:
2830         case NAME:
2831         case STRUCT:
2832         case CONTEXT:
2833         case PARAMETERS:
2834         case LENGTH:
2835         case TDO:
2836         case MAXLEN:
2837         case CHARSETID:
2838         case CHARSETFORM:
2839         case ACCEPT:
2840         case ACCESSIBLE:
2841         case COPY:
2842         case DEFINE:
2843         case DISCONNECT:
2844         case HOST:
2845         case PRINT:
2846         case QUIT:
2847         case REMARK:
2848         case UNDEFINE:
2849         case VARIABLE:
2850         case WHENEVER:
2851         case ATTACH:
2852         case CAST:
2853         case TREAT:
2854         case TRIM:
2855         case LEFT:
2856         case RIGHT:
2857         case BOTH:
2858         case EMPTY:
2859         case MULTISET:
2860         case SUBMULTISET:
2861         case LEADING:
2862         case TRAILING:
2863         case CHAR_CS:
2864         case NCHAR_CS:
2865         case DBTIMEZONE:
2866         case SESSIONTIMEZONE:
2867         case AUTHENTICATED:
2868         case LINK:
2869         case SHARED:
2870         case DIRECTORY:
2871         case USER:
2872         case IDENTIFIER:
2873         case QUOTED_LITERAL:
2874         case SQLDATA_CLASS:
2875         case CUSTOMDATUM_CLASS:
2876         case ORADATA_CLASS:
2877         case JAVA_INTERFACE_CLASS:
2878           ;
2879           break;
2880         default:
2881           jj_la1[34] = jj_gen;
2882           break label_8;
2883         }
2884         switch (jj_nt.kind) {
2885         case REPLACE:
2886         case DEFINER:
2887         case CURRENT_USER:
2888         case SERIALLY_REUSABLE:
2889         case RESTRICT_REFERENCES:
2890         case EXCEPTION_INIT:
2891         case AUTONOMOUS_TRANSACTION:
2892         case LANGUAGE:
2893         case ADD:
2894         case AGGREGATE:
2895         case ALL:
2896         case ALTER:
2897         case AND:
2898         case ANY:
2899         case ARRAY:
2900         case AS:
2901         case ASC:
2902         case AT:
2903         case ATTRIBUTE:
2904         case AUTHID:
2905         case AVG:
2906         case BETWEEN:
2907         case BINARY_INTEGER:
2908         case BODY:
2909         case BOOLEAN:
2910         case BULK:
2911         case BY:
2912         case BYTE:
2913         case CASCADE:
2914         case CASE:
2915         case CHAR:
2916         case CHAR_BASE:
2917         case CHECK:
2918         case CLOSE:
2919         case CLUSTER:
2920         case COALESCE:
2921         case COLLECT:
2922         case COLUMN:
2923         case COMMENT:
2924         case COMMIT:
2925         case COMPRESS:
2926         case CONNECT:
2927         case CONSTANT:
2928         case CONSTRUCTOR:
2929         case CONTINUE:
2930         case CONVERT:
2931         case CREATE:
2932         case CURRENT:
2933         case CURRVAL:
2934         case CURSOR:
2935         case DATA:
2936         case DATE:
2937         case DAY:
2938         case DECLARE:
2939         case DECIMAL:
2940         case _DEFAULT:
2941         case DELETE:
2942         case DESC:
2943         case DISABLE:
2944         case DISTINCT:
2945         case DO:
2946         case DROP:
2947         case EDITIONABLE:
2948         case ELEMENT:
2949         case ELSE:
2950         case ELSIF:
2951         case ENABLE:
2952         case ESCAPE:
2953         case EXCEPT:
2954         case EXCEPTION:
2955         case EXCEPTIONS:
2956         case EXCLUSIVE:
2957         case EXECUTE:
2958         case EXISTS:
2959         case EXIT:
2960         case EXTERNAL:
2961         case EXTENDS:
2962         case EXTRACT:
2963         case FALSE:
2964         case FETCH:
2965         case FINAL:
2966         case FLOAT:
2967         case FOR:
2968         case FORALL:
2969         case FORCE:
2970         case FROM:
2971         case FUNCTION:
2972         case GLOBAL:
2973         case GOTO:
2974         case GROUP:
2975         case HASH:
2976         case HAVING:
2977         case HEAP:
2978         case HOUR:
2979         case IF:
2980         case IMMEDIATE:
2981         case IN:
2982         case INDEX:
2983         case INDICES:
2984         case INDEXTYPE:
2985         case INDICATOR:
2986         case INSERT:
2987         case INSTANTIABLE:
2988         case INTEGER:
2989         case INTERFACE:
2990         case INTERSECT:
2991         case INTERVAL:
2992         case INTO:
2993         case INVALIDATE:
2994         case IS:
2995         case ISOLATION:
2996         case JAVA:
2997         case LEVEL:
2998         case LIKE:
2999         case LIMIT:
3000         case LIMITED:
3001         case LOCK:
3002         case LONG:
3003         case LOOP:
3004         case MAP:
3005         case MAX:
3006         case MEMBER:
3007         case MERGE:
3008         case MIN:
3009         case MINUS:
3010         case MINUTE:
3011         case MLSLABEL:
3012         case MODIFY:
3013         case MOD:
3014         case MODE:
3015         case MONTH:
3016         case NATURAL:
3017         case NATURALN:
3018         case NEW:
3019         case NEXTVAL:
3020         case NO:
3021         case NOCOPY:
3022         case NONEDITIONABLE:
3023         case NOT:
3024         case NOWAIT:
3025         case NULL:
3026         case NULLIF:
3027         case NUMBER:
3028         case BFILE_BASE:
3029         case BLOB_BASE:
3030         case CLOB_BASE:
3031         case DATE_BASE:
3032         case NUMBER_BASE:
3033         case OBJECT:
3034         case OCIROWID:
3035         case OF:
3036         case OID:
3037         case ON:
3038         case OPAQUE:
3039         case OPEN:
3040         case OPERATOR:
3041         case OPTION:
3042         case OR:
3043         case ORDER:
3044         case ORGANIZATION:
3045         case OTHERS:
3046         case OUT:
3047         case OVERRIDING:
3048         case PACKAGE:
3049         case PARTITION:
3050         case PCTFREE:
3051         case PLS_INTEGER:
3052         case POSITIVE:
3053         case POSITIVEN:
3054         case PRAGMA:
3055         case PRESERVE:
3056         case PRIOR:
3057         case PROMPT:
3058         case PRIVATE:
3059         case PROCEDURE:
3060         case PUBLIC:
3061         case RAISE:
3062         case RANGE:
3063         case RAW:
3064         case REAL:
3065         case RECORD:
3066         case REF:
3067         case RELEASE:
3068         case RELIES_ON:
3069         case RENAME:
3070         case RESULT:
3071         case RETURN:
3072         case RETURNING:
3073         case REVERSE:
3074         case ROLLBACK:
3075         case ROW:
3076         case ROWS:
3077         case ROWID:
3078         case ROWNUM:
3079         case ROWTYPE:
3080         case SAVE:
3081         case SAVEPOINT:
3082         case SECOND:
3083         case SELECT:
3084         case SELF:
3085         case SEPARATE:
3086         case SET:
3087         case SHARE:
3088         case SMALLINT:
3089         case SPACE:
3090         case SQL:
3091         case SQLCODE:
3092         case SQLERRM:
3093         case START:
3094         case STATIC:
3095         case STDDEV:
3096         case SUBTYPE:
3097         case SUBSTITUTABLE:
3098         case SUCCESSFUL:
3099         case SUM:
3100         case SYNONYM:
3101         case SYSDATE:
3102         case SYS_REFCURSOR:
3103         case TABLE:
3104         case TEMPORARY:
3105         case THEN:
3106         case TIME:
3107         case TIMESTAMP:
3108         case TIMEZONE_REGION:
3109         case TIMEZONE_ABBR:
3110         case TIMEZONE_MINUTE:
3111         case TIMEZONE_HOUR:
3112         case TO:
3113         case TRANSACTION:
3114         case TRIGGER:
3115         case TRUE:
3116         case TYPE:
3117         case UI:
3118         case UNDER:
3119         case USING:
3120         case WHILE:
3121         case YES:
3122         case SHOW:
3123         case A:
3124         case UPDATE:
3125         case VARCHAR:
3126         case VARCHAR2:
3127         case DOUBLE:
3128         case DEC:
3129         case PRECISION:
3130         case INT:
3131         case NUMERIC:
3132         case SIGNTYPE:
3133         case NCHAR:
3134         case NVARCHAR2:
3135         case STRING:
3136         case UROWID:
3137         case VARRAY:
3138         case VARYING:
3139         case BFILE:
3140         case BLOB:
3141         case CLOB:
3142         case NCLOB:
3143         case YEAR:
3144         case LOCAL:
3145         case WITH:
3146         case ZONE:
3147         case CHARACTER:
3148         case AFTER:
3149         case BEFORE:
3150         case OLD:
3151         case PARENT:
3152         case CC_IF:
3153         case ANALYZE:
3154         case ASSOCIATE:
3155         case AUDIT:
3156         case COMPOUND:
3157         case DATABASE:
3158         case CALL:
3159         case DDL:
3160         case DISASSOCIATE:
3161         case EACH:
3162         case FOLLOWS:
3163         case LOGOFF:
3164         case LOGON:
3165         case NESTED:
3166         case NOAUDIT:
3167         case SCHEMA:
3168         case SERVERERROR:
3169         case SHUTDOWN:
3170         case STARTUP:
3171         case STATEMENT:
3172         case STATISTICS:
3173         case SUSPEND:
3174         case TRUNCATE:
3175         case WRAPPED:
3176         case LIBRARY:
3177         case NAME:
3178         case STRUCT:
3179         case CONTEXT:
3180         case PARAMETERS:
3181         case LENGTH:
3182         case TDO:
3183         case MAXLEN:
3184         case CHARSETID:
3185         case CHARSETFORM:
3186         case ACCEPT:
3187         case ACCESSIBLE:
3188         case COPY:
3189         case DEFINE:
3190         case DISCONNECT:
3191         case HOST:
3192         case PRINT:
3193         case QUIT:
3194         case REMARK:
3195         case UNDEFINE:
3196         case VARIABLE:
3197         case WHENEVER:
3198         case ATTACH:
3199         case CAST:
3200         case TREAT:
3201         case TRIM:
3202         case LEFT:
3203         case RIGHT:
3204         case BOTH:
3205         case EMPTY:
3206         case MULTISET:
3207         case SUBMULTISET:
3208         case LEADING:
3209         case TRAILING:
3210         case CHAR_CS:
3211         case NCHAR_CS:
3212         case DBTIMEZONE:
3213         case SESSIONTIMEZONE:
3214         case AUTHENTICATED:
3215         case LINK:
3216         case SHARED:
3217         case DIRECTORY:
3218         case USER:
3219         case IDENTIFIER:
3220         case QUOTED_LITERAL:
3221         case SQLDATA_CLASS:
3222         case CUSTOMDATUM_CLASS:
3223         case ORADATA_CLASS:
3224         case JAVA_INTERFACE_CLASS:
3225           DeclarativeUnit();
3226           break;
3227         case CC_ERROR:
3228           jj_consume_token(CC_ERROR);
3229           Expression();
3230           jj_consume_token(CC_END);
3231           break;
3232         default:
3233           jj_la1[35] = jj_gen;
3234           jj_consume_token(-1);
3235           throw new ParseException();
3236         }
3237       }
3238       label_9:
3239       while (true) {
3240         switch (jj_nt.kind) {
3241         case CC_ELSIF:
3242           ;
3243           break;
3244         default:
3245           jj_la1[36] = jj_gen;
3246           break label_9;
3247         }
3248         jj_consume_token(CC_ELSIF);
3249         ConditionalOrExpression();
3250         jj_consume_token(CC_THEN);
3251         label_10:
3252         while (true) {
3253           switch (jj_nt.kind) {
3254           case REPLACE:
3255           case DEFINER:
3256           case CURRENT_USER:
3257           case SERIALLY_REUSABLE:
3258           case RESTRICT_REFERENCES:
3259           case EXCEPTION_INIT:
3260           case AUTONOMOUS_TRANSACTION:
3261           case LANGUAGE:
3262           case ADD:
3263           case AGGREGATE:
3264           case ALL:
3265           case ALTER:
3266           case AND:
3267           case ANY:
3268           case ARRAY:
3269           case AS:
3270           case ASC:
3271           case AT:
3272           case ATTRIBUTE:
3273           case AUTHID:
3274           case AVG:
3275           case BETWEEN:
3276           case BINARY_INTEGER:
3277           case BODY:
3278           case BOOLEAN:
3279           case BULK:
3280           case BY:
3281           case BYTE:
3282           case CASCADE:
3283           case CASE:
3284           case CHAR:
3285           case CHAR_BASE:
3286           case CHECK:
3287           case CLOSE:
3288           case CLUSTER:
3289           case COALESCE:
3290           case COLLECT:
3291           case COLUMN:
3292           case COMMENT:
3293           case COMMIT:
3294           case COMPRESS:
3295           case CONNECT:
3296           case CONSTANT:
3297           case CONSTRUCTOR:
3298           case CONTINUE:
3299           case CONVERT:
3300           case CREATE:
3301           case CURRENT:
3302           case CURRVAL:
3303           case CURSOR:
3304           case DATA:
3305           case DATE:
3306           case DAY:
3307           case DECLARE:
3308           case DECIMAL:
3309           case _DEFAULT:
3310           case DELETE:
3311           case DESC:
3312           case DISABLE:
3313           case DISTINCT:
3314           case DO:
3315           case DROP:
3316           case EDITIONABLE:
3317           case ELEMENT:
3318           case ELSE:
3319           case ELSIF:
3320           case ENABLE:
3321           case ESCAPE:
3322           case EXCEPT:
3323           case EXCEPTION:
3324           case EXCEPTIONS:
3325           case EXCLUSIVE:
3326           case EXECUTE:
3327           case EXISTS:
3328           case EXIT:
3329           case EXTERNAL:
3330           case EXTENDS:
3331           case EXTRACT:
3332           case FALSE:
3333           case FETCH:
3334           case FINAL:
3335           case FLOAT:
3336           case FOR:
3337           case FORALL:
3338           case FORCE:
3339           case FROM:
3340           case FUNCTION:
3341           case GLOBAL:
3342           case GOTO:
3343           case GROUP:
3344           case HASH:
3345           case HAVING:
3346           case HEAP:
3347           case HOUR:
3348           case IF:
3349           case IMMEDIATE:
3350           case IN:
3351           case INDEX:
3352           case INDICES:
3353           case INDEXTYPE:
3354           case INDICATOR:
3355           case INSERT:
3356           case INSTANTIABLE:
3357           case INTEGER:
3358           case INTERFACE:
3359           case INTERSECT:
3360           case INTERVAL:
3361           case INTO:
3362           case INVALIDATE:
3363           case IS:
3364           case ISOLATION:
3365           case JAVA:
3366           case LEVEL:
3367           case LIKE:
3368           case LIMIT:
3369           case LIMITED:
3370           case LOCK:
3371           case LONG:
3372           case LOOP:
3373           case MAP:
3374           case MAX:
3375           case MEMBER:
3376           case MERGE:
3377           case MIN:
3378           case MINUS:
3379           case MINUTE:
3380           case MLSLABEL:
3381           case MODIFY:
3382           case MOD:
3383           case MODE:
3384           case MONTH:
3385           case NATURAL:
3386           case NATURALN:
3387           case NEW:
3388           case NEXTVAL:
3389           case NO:
3390           case NOCOPY:
3391           case NONEDITIONABLE:
3392           case NOT:
3393           case NOWAIT:
3394           case NULL:
3395           case NULLIF:
3396           case NUMBER:
3397           case BFILE_BASE:
3398           case BLOB_BASE:
3399           case CLOB_BASE:
3400           case DATE_BASE:
3401           case NUMBER_BASE:
3402           case OBJECT:
3403           case OCIROWID:
3404           case OF:
3405           case OID:
3406           case ON:
3407           case OPAQUE:
3408           case OPEN:
3409           case OPERATOR:
3410           case OPTION:
3411           case OR:
3412           case ORDER:
3413           case ORGANIZATION:
3414           case OTHERS:
3415           case OUT:
3416           case OVERRIDING:
3417           case PACKAGE:
3418           case PARTITION:
3419           case PCTFREE:
3420           case PLS_INTEGER:
3421           case POSITIVE:
3422           case POSITIVEN:
3423           case PRAGMA:
3424           case PRESERVE:
3425           case PRIOR:
3426           case PROMPT:
3427           case PRIVATE:
3428           case PROCEDURE:
3429           case PUBLIC:
3430           case RAISE:
3431           case RANGE:
3432           case RAW:
3433           case REAL:
3434           case RECORD:
3435           case REF:
3436           case RELEASE:
3437           case RELIES_ON:
3438           case RENAME:
3439           case RESULT:
3440           case RETURN:
3441           case RETURNING:
3442           case REVERSE:
3443           case ROLLBACK:
3444           case ROW:
3445           case ROWS:
3446           case ROWID:
3447           case ROWNUM:
3448           case ROWTYPE:
3449           case SAVE:
3450           case SAVEPOINT:
3451           case SECOND:
3452           case SELECT:
3453           case SELF:
3454           case SEPARATE:
3455           case SET:
3456           case SHARE:
3457           case SMALLINT:
3458           case SPACE:
3459           case SQL:
3460           case SQLCODE:
3461           case SQLERRM:
3462           case START:
3463           case STATIC:
3464           case STDDEV:
3465           case SUBTYPE:
3466           case SUBSTITUTABLE:
3467           case SUCCESSFUL:
3468           case SUM:
3469           case SYNONYM:
3470           case SYSDATE:
3471           case SYS_REFCURSOR:
3472           case TABLE:
3473           case TEMPORARY:
3474           case THEN:
3475           case TIME:
3476           case TIMESTAMP:
3477           case TIMEZONE_REGION:
3478           case TIMEZONE_ABBR:
3479           case TIMEZONE_MINUTE:
3480           case TIMEZONE_HOUR:
3481           case TO:
3482           case TRANSACTION:
3483           case TRIGGER:
3484           case TRUE:
3485           case TYPE:
3486           case UI:
3487           case UNDER:
3488           case USING:
3489           case WHILE:
3490           case YES:
3491           case SHOW:
3492           case A:
3493           case UPDATE:
3494           case VARCHAR:
3495           case VARCHAR2:
3496           case DOUBLE:
3497           case DEC:
3498           case PRECISION:
3499           case INT:
3500           case NUMERIC:
3501           case SIGNTYPE:
3502           case NCHAR:
3503           case NVARCHAR2:
3504           case STRING:
3505           case UROWID:
3506           case VARRAY:
3507           case VARYING:
3508           case BFILE:
3509           case BLOB:
3510           case CLOB:
3511           case NCLOB:
3512           case YEAR:
3513           case LOCAL:
3514           case WITH:
3515           case ZONE:
3516           case CHARACTER:
3517           case AFTER:
3518           case BEFORE:
3519           case OLD:
3520           case PARENT:
3521           case CC_IF:
3522           case CC_ERROR:
3523           case ANALYZE:
3524           case ASSOCIATE:
3525           case AUDIT:
3526           case COMPOUND:
3527           case DATABASE:
3528           case CALL:
3529           case DDL:
3530           case DISASSOCIATE:
3531           case EACH:
3532           case FOLLOWS:
3533           case LOGOFF:
3534           case LOGON:
3535           case NESTED:
3536           case NOAUDIT:
3537           case SCHEMA:
3538           case SERVERERROR:
3539           case SHUTDOWN:
3540           case STARTUP:
3541           case STATEMENT:
3542           case STATISTICS:
3543           case SUSPEND:
3544           case TRUNCATE:
3545           case WRAPPED:
3546           case LIBRARY:
3547           case NAME:
3548           case STRUCT:
3549           case CONTEXT:
3550           case PARAMETERS:
3551           case LENGTH:
3552           case TDO:
3553           case MAXLEN:
3554           case CHARSETID:
3555           case CHARSETFORM:
3556           case ACCEPT:
3557           case ACCESSIBLE:
3558           case COPY:
3559           case DEFINE:
3560           case DISCONNECT:
3561           case HOST:
3562           case PRINT:
3563           case QUIT:
3564           case REMARK:
3565           case UNDEFINE:
3566           case VARIABLE:
3567           case WHENEVER:
3568           case ATTACH:
3569           case CAST:
3570           case TREAT:
3571           case TRIM:
3572           case LEFT:
3573           case RIGHT:
3574           case BOTH:
3575           case EMPTY:
3576           case MULTISET:
3577           case SUBMULTISET:
3578           case LEADING:
3579           case TRAILING:
3580           case CHAR_CS:
3581           case NCHAR_CS:
3582           case DBTIMEZONE:
3583           case SESSIONTIMEZONE:
3584           case AUTHENTICATED:
3585           case LINK:
3586           case SHARED:
3587           case DIRECTORY:
3588           case USER:
3589           case IDENTIFIER:
3590           case QUOTED_LITERAL:
3591           case SQLDATA_CLASS:
3592           case CUSTOMDATUM_CLASS:
3593           case ORADATA_CLASS:
3594           case JAVA_INTERFACE_CLASS:
3595             ;
3596             break;
3597           default:
3598             jj_la1[37] = jj_gen;
3599             break label_10;
3600           }
3601           switch (jj_nt.kind) {
3602           case REPLACE:
3603           case DEFINER:
3604           case CURRENT_USER:
3605           case SERIALLY_REUSABLE:
3606           case RESTRICT_REFERENCES:
3607           case EXCEPTION_INIT:
3608           case AUTONOMOUS_TRANSACTION:
3609           case LANGUAGE:
3610           case ADD:
3611           case AGGREGATE:
3612           case ALL:
3613           case ALTER:
3614           case AND:
3615           case ANY:
3616           case ARRAY:
3617           case AS:
3618           case ASC:
3619           case AT:
3620           case ATTRIBUTE:
3621           case AUTHID:
3622           case AVG:
3623           case BETWEEN:
3624           case BINARY_INTEGER:
3625           case BODY:
3626           case BOOLEAN:
3627           case BULK:
3628           case BY:
3629           case BYTE:
3630           case CASCADE:
3631           case CASE:
3632           case CHAR:
3633           case CHAR_BASE:
3634           case CHECK:
3635           case CLOSE:
3636           case CLUSTER:
3637           case COALESCE:
3638           case COLLECT:
3639           case COLUMN:
3640           case COMMENT:
3641           case COMMIT:
3642           case COMPRESS:
3643           case CONNECT:
3644           case CONSTANT:
3645           case CONSTRUCTOR:
3646           case CONTINUE:
3647           case CONVERT:
3648           case CREATE:
3649           case CURRENT:
3650           case CURRVAL:
3651           case CURSOR:
3652           case DATA:
3653           case DATE:
3654           case DAY:
3655           case DECLARE:
3656           case DECIMAL:
3657           case _DEFAULT:
3658           case DELETE:
3659           case DESC:
3660           case DISABLE:
3661           case DISTINCT:
3662           case DO:
3663           case DROP:
3664           case EDITIONABLE:
3665           case ELEMENT:
3666           case ELSE:
3667           case ELSIF:
3668           case ENABLE:
3669           case ESCAPE:
3670           case EXCEPT:
3671           case EXCEPTION:
3672           case EXCEPTIONS:
3673           case EXCLUSIVE:
3674           case EXECUTE:
3675           case EXISTS:
3676           case EXIT:
3677           case EXTERNAL:
3678           case EXTENDS:
3679           case EXTRACT:
3680           case FALSE:
3681           case FETCH:
3682           case FINAL:
3683           case FLOAT:
3684           case FOR:
3685           case FORALL:
3686           case FORCE:
3687           case FROM:
3688           case FUNCTION:
3689           case GLOBAL:
3690           case GOTO:
3691           case GROUP:
3692           case HASH:
3693           case HAVING:
3694           case HEAP:
3695           case HOUR:
3696           case IF:
3697           case IMMEDIATE:
3698           case IN:
3699           case INDEX:
3700           case INDICES:
3701           case INDEXTYPE:
3702           case INDICATOR:
3703           case INSERT:
3704           case INSTANTIABLE:
3705           case INTEGER:
3706           case INTERFACE:
3707           case INTERSECT:
3708           case INTERVAL:
3709           case INTO:
3710           case INVALIDATE:
3711           case IS:
3712           case ISOLATION:
3713           case JAVA:
3714           case LEVEL:
3715           case LIKE:
3716           case LIMIT:
3717           case LIMITED:
3718           case LOCK:
3719           case LONG:
3720           case LOOP:
3721           case MAP:
3722           case MAX:
3723           case MEMBER:
3724           case MERGE:
3725           case MIN:
3726           case MINUS:
3727           case MINUTE:
3728           case MLSLABEL:
3729           case MODIFY:
3730           case MOD:
3731           case MODE:
3732           case MONTH:
3733           case NATURAL:
3734           case NATURALN:
3735           case NEW:
3736           case NEXTVAL:
3737           case NO:
3738           case NOCOPY:
3739           case NONEDITIONABLE:
3740           case NOT:
3741           case NOWAIT:
3742           case NULL:
3743           case NULLIF:
3744           case NUMBER:
3745           case BFILE_BASE:
3746           case BLOB_BASE:
3747           case CLOB_BASE:
3748           case DATE_BASE:
3749           case NUMBER_BASE:
3750           case OBJECT:
3751           case OCIROWID:
3752           case OF:
3753           case OID:
3754           case ON:
3755           case OPAQUE:
3756           case OPEN:
3757           case OPERATOR:
3758           case OPTION:
3759           case OR:
3760           case ORDER:
3761           case ORGANIZATION:
3762           case OTHERS:
3763           case OUT:
3764           case OVERRIDING:
3765           case PACKAGE:
3766           case PARTITION:
3767           case PCTFREE:
3768           case PLS_INTEGER:
3769           case POSITIVE:
3770           case POSITIVEN:
3771           case PRAGMA:
3772           case PRESERVE:
3773           case PRIOR:
3774           case PROMPT:
3775           case PRIVATE:
3776           case PROCEDURE:
3777           case PUBLIC:
3778           case RAISE:
3779           case RANGE:
3780           case RAW:
3781           case REAL:
3782           case RECORD:
3783           case REF:
3784           case RELEASE:
3785           case RELIES_ON:
3786           case RENAME:
3787           case RESULT:
3788           case RETURN:
3789           case RETURNING:
3790           case REVERSE:
3791           case ROLLBACK:
3792           case ROW:
3793           case ROWS:
3794           case ROWID:
3795           case ROWNUM:
3796           case ROWTYPE:
3797           case SAVE:
3798           case SAVEPOINT:
3799           case SECOND:
3800           case SELECT:
3801           case SELF:
3802           case SEPARATE:
3803           case SET:
3804           case SHARE:
3805           case SMALLINT:
3806           case SPACE:
3807           case SQL:
3808           case SQLCODE:
3809           case SQLERRM:
3810           case START:
3811           case STATIC:
3812           case STDDEV:
3813           case SUBTYPE:
3814           case SUBSTITUTABLE:
3815           case SUCCESSFUL:
3816           case SUM:
3817           case SYNONYM:
3818           case SYSDATE:
3819           case SYS_REFCURSOR:
3820           case TABLE:
3821           case TEMPORARY:
3822           case THEN:
3823           case TIME:
3824           case TIMESTAMP:
3825           case TIMEZONE_REGION:
3826           case TIMEZONE_ABBR:
3827           case TIMEZONE_MINUTE:
3828           case TIMEZONE_HOUR:
3829           case TO:
3830           case TRANSACTION:
3831           case TRIGGER:
3832           case TRUE:
3833           case TYPE:
3834           case UI:
3835           case UNDER:
3836           case USING:
3837           case WHILE:
3838           case YES:
3839           case SHOW:
3840           case A:
3841           case UPDATE:
3842           case VARCHAR:
3843           case VARCHAR2:
3844           case DOUBLE:
3845           case DEC:
3846           case PRECISION:
3847           case INT:
3848           case NUMERIC:
3849           case SIGNTYPE:
3850           case NCHAR:
3851           case NVARCHAR2:
3852           case STRING:
3853           case UROWID:
3854           case VARRAY:
3855           case VARYING:
3856           case BFILE:
3857           case BLOB:
3858           case CLOB:
3859           case NCLOB:
3860           case YEAR:
3861           case LOCAL:
3862           case WITH:
3863           case ZONE:
3864           case CHARACTER:
3865           case AFTER:
3866           case BEFORE:
3867           case OLD:
3868           case PARENT:
3869           case CC_IF:
3870           case ANALYZE:
3871           case ASSOCIATE:
3872           case AUDIT:
3873           case COMPOUND:
3874           case DATABASE:
3875           case CALL:
3876           case DDL:
3877           case DISASSOCIATE:
3878           case EACH:
3879           case FOLLOWS:
3880           case LOGOFF:
3881           case LOGON:
3882           case NESTED:
3883           case NOAUDIT:
3884           case SCHEMA:
3885           case SERVERERROR:
3886           case SHUTDOWN:
3887           case STARTUP:
3888           case STATEMENT:
3889           case STATISTICS:
3890           case SUSPEND:
3891           case TRUNCATE:
3892           case WRAPPED:
3893           case LIBRARY:
3894           case NAME:
3895           case STRUCT:
3896           case CONTEXT:
3897           case PARAMETERS:
3898           case LENGTH:
3899           case TDO:
3900           case MAXLEN:
3901           case CHARSETID:
3902           case CHARSETFORM:
3903           case ACCEPT:
3904           case ACCESSIBLE:
3905           case COPY:
3906           case DEFINE:
3907           case DISCONNECT:
3908           case HOST:
3909           case PRINT:
3910           case QUIT:
3911           case REMARK:
3912           case UNDEFINE:
3913           case VARIABLE:
3914           case WHENEVER:
3915           case ATTACH:
3916           case CAST:
3917           case TREAT:
3918           case TRIM:
3919           case LEFT:
3920           case RIGHT:
3921           case BOTH:
3922           case EMPTY:
3923           case MULTISET:
3924           case SUBMULTISET:
3925           case LEADING:
3926           case TRAILING:
3927           case CHAR_CS:
3928           case NCHAR_CS:
3929           case DBTIMEZONE:
3930           case SESSIONTIMEZONE:
3931           case AUTHENTICATED:
3932           case LINK:
3933           case SHARED:
3934           case DIRECTORY:
3935           case USER:
3936           case IDENTIFIER:
3937           case QUOTED_LITERAL:
3938           case SQLDATA_CLASS:
3939           case CUSTOMDATUM_CLASS:
3940           case ORADATA_CLASS:
3941           case JAVA_INTERFACE_CLASS:
3942             DeclarativeUnit();
3943             break;
3944           case CC_ERROR:
3945             jj_consume_token(CC_ERROR);
3946             Expression();
3947             jj_consume_token(CC_END);
3948             break;
3949           default:
3950             jj_la1[38] = jj_gen;
3951             jj_consume_token(-1);
3952             throw new ParseException();
3953           }
3954         }
3955       }
3956       label_11:
3957       while (true) {
3958         switch (jj_nt.kind) {
3959         case CC_ELSE:
3960           ;
3961           break;
3962         default:
3963           jj_la1[39] = jj_gen;
3964           break label_11;
3965         }
3966         jj_consume_token(CC_ELSE);
3967         label_12:
3968         while (true) {
3969           switch (jj_nt.kind) {
3970           case REPLACE:
3971           case DEFINER:
3972           case CURRENT_USER:
3973           case SERIALLY_REUSABLE:
3974           case RESTRICT_REFERENCES:
3975           case EXCEPTION_INIT:
3976           case AUTONOMOUS_TRANSACTION:
3977           case LANGUAGE:
3978           case ADD:
3979           case AGGREGATE:
3980           case ALL:
3981           case ALTER:
3982           case AND:
3983           case ANY:
3984           case ARRAY:
3985           case AS:
3986           case ASC:
3987           case AT:
3988           case ATTRIBUTE:
3989           case AUTHID:
3990           case AVG:
3991           case BETWEEN:
3992           case BINARY_INTEGER:
3993           case BODY:
3994           case BOOLEAN:
3995           case BULK:
3996           case BY:
3997           case BYTE:
3998           case CASCADE:
3999           case CASE:
4000           case CHAR:
4001           case CHAR_BASE:
4002           case CHECK:
4003           case CLOSE:
4004           case CLUSTER:
4005           case COALESCE:
4006           case COLLECT:
4007           case COLUMN:
4008           case COMMENT:
4009           case COMMIT:
4010           case COMPRESS:
4011           case CONNECT:
4012           case CONSTANT:
4013           case CONSTRUCTOR:
4014           case CONTINUE:
4015           case CONVERT:
4016           case CREATE:
4017           case CURRENT:
4018           case CURRVAL:
4019           case CURSOR:
4020           case DATA:
4021           case DATE:
4022           case DAY:
4023           case DECLARE:
4024           case DECIMAL:
4025           case _DEFAULT:
4026           case DELETE:
4027           case DESC:
4028           case DISABLE:
4029           case DISTINCT:
4030           case DO:
4031           case DROP:
4032           case EDITIONABLE:
4033           case ELEMENT:
4034           case ELSE:
4035           case ELSIF:
4036           case ENABLE:
4037           case ESCAPE:
4038           case EXCEPT:
4039           case EXCEPTION:
4040           case EXCEPTIONS:
4041           case EXCLUSIVE:
4042           case EXECUTE:
4043           case EXISTS:
4044           case EXIT:
4045           case EXTERNAL:
4046           case EXTENDS:
4047           case EXTRACT:
4048           case FALSE:
4049           case FETCH:
4050           case FINAL:
4051           case FLOAT:
4052           case FOR:
4053           case FORALL:
4054           case FORCE:
4055           case FROM:
4056           case FUNCTION:
4057           case GLOBAL:
4058           case GOTO:
4059           case GROUP:
4060           case HASH:
4061           case HAVING:
4062           case HEAP:
4063           case HOUR:
4064           case IF:
4065           case IMMEDIATE:
4066           case IN:
4067           case INDEX:
4068           case INDICES:
4069           case INDEXTYPE:
4070           case INDICATOR:
4071           case INSERT:
4072           case INSTANTIABLE:
4073           case INTEGER:
4074           case INTERFACE:
4075           case INTERSECT:
4076           case INTERVAL:
4077           case INTO:
4078           case INVALIDATE:
4079           case IS:
4080           case ISOLATION:
4081           case JAVA:
4082           case LEVEL:
4083           case LIKE:
4084           case LIMIT:
4085           case LIMITED:
4086           case LOCK:
4087           case LONG:
4088           case LOOP:
4089           case MAP:
4090           case MAX:
4091           case MEMBER:
4092           case MERGE:
4093           case MIN:
4094           case MINUS:
4095           case MINUTE:
4096           case MLSLABEL:
4097           case MODIFY:
4098           case MOD:
4099           case MODE:
4100           case MONTH:
4101           case NATURAL:
4102           case NATURALN:
4103           case NEW:
4104           case NEXTVAL:
4105           case NO:
4106           case NOCOPY:
4107           case NONEDITIONABLE:
4108           case NOT:
4109           case NOWAIT:
4110           case NULL:
4111           case NULLIF:
4112           case NUMBER:
4113           case BFILE_BASE:
4114           case BLOB_BASE:
4115           case CLOB_BASE:
4116           case DATE_BASE:
4117           case NUMBER_BASE:
4118           case OBJECT:
4119           case OCIROWID:
4120           case OF:
4121           case OID:
4122           case ON:
4123           case OPAQUE:
4124           case OPEN:
4125           case OPERATOR:
4126           case OPTION:
4127           case OR:
4128           case ORDER:
4129           case ORGANIZATION:
4130           case OTHERS:
4131           case OUT:
4132           case OVERRIDING:
4133           case PACKAGE:
4134           case PARTITION:
4135           case PCTFREE:
4136           case PLS_INTEGER:
4137           case POSITIVE:
4138           case POSITIVEN:
4139           case PRAGMA:
4140           case PRESERVE:
4141           case PRIOR:
4142           case PROMPT:
4143           case PRIVATE:
4144           case PROCEDURE:
4145           case PUBLIC:
4146           case RAISE:
4147           case RANGE:
4148           case RAW:
4149           case REAL:
4150           case RECORD:
4151           case REF:
4152           case RELEASE:
4153           case RELIES_ON:
4154           case RENAME:
4155           case RESULT:
4156           case RETURN:
4157           case RETURNING:
4158           case REVERSE:
4159           case ROLLBACK:
4160           case ROW:
4161           case ROWS:
4162           case ROWID:
4163           case ROWNUM:
4164           case ROWTYPE:
4165           case SAVE:
4166           case SAVEPOINT:
4167           case SECOND:
4168           case SELECT:
4169           case SELF:
4170           case SEPARATE:
4171           case SET:
4172           case SHARE:
4173           case SMALLINT:
4174           case SPACE:
4175           case SQL:
4176           case SQLCODE:
4177           case SQLERRM:
4178           case START:
4179           case STATIC:
4180           case STDDEV:
4181           case SUBTYPE:
4182           case SUBSTITUTABLE:
4183           case SUCCESSFUL:
4184           case SUM:
4185           case SYNONYM:
4186           case SYSDATE:
4187           case SYS_REFCURSOR:
4188           case TABLE:
4189           case TEMPORARY:
4190           case THEN:
4191           case TIME:
4192           case TIMESTAMP:
4193           case TIMEZONE_REGION:
4194           case TIMEZONE_ABBR:
4195           case TIMEZONE_MINUTE:
4196           case TIMEZONE_HOUR:
4197           case TO:
4198           case TRANSACTION:
4199           case TRIGGER:
4200           case TRUE:
4201           case TYPE:
4202           case UI:
4203           case UNDER:
4204           case USING:
4205           case WHILE:
4206           case YES:
4207           case SHOW:
4208           case A:
4209           case UPDATE:
4210           case VARCHAR:
4211           case VARCHAR2:
4212           case DOUBLE:
4213           case DEC:
4214           case PRECISION:
4215           case INT:
4216           case NUMERIC:
4217           case SIGNTYPE:
4218           case NCHAR:
4219           case NVARCHAR2:
4220           case STRING:
4221           case UROWID:
4222           case VARRAY:
4223           case VARYING:
4224           case BFILE:
4225           case BLOB:
4226           case CLOB:
4227           case NCLOB:
4228           case YEAR:
4229           case LOCAL:
4230           case WITH:
4231           case ZONE:
4232           case CHARACTER:
4233           case AFTER:
4234           case BEFORE:
4235           case OLD:
4236           case PARENT:
4237           case CC_IF:
4238           case CC_ERROR:
4239           case ANALYZE:
4240           case ASSOCIATE:
4241           case AUDIT:
4242           case COMPOUND:
4243           case DATABASE:
4244           case CALL:
4245           case DDL:
4246           case DISASSOCIATE:
4247           case EACH:
4248           case FOLLOWS:
4249           case LOGOFF:
4250           case LOGON:
4251           case NESTED:
4252           case NOAUDIT:
4253           case SCHEMA:
4254           case SERVERERROR:
4255           case SHUTDOWN:
4256           case STARTUP:
4257           case STATEMENT:
4258           case STATISTICS:
4259           case SUSPEND:
4260           case TRUNCATE:
4261           case WRAPPED:
4262           case LIBRARY:
4263           case NAME:
4264           case STRUCT:
4265           case CONTEXT:
4266           case PARAMETERS:
4267           case LENGTH:
4268           case TDO:
4269           case MAXLEN:
4270           case CHARSETID:
4271           case CHARSETFORM:
4272           case ACCEPT:
4273           case ACCESSIBLE:
4274           case COPY:
4275           case DEFINE:
4276           case DISCONNECT:
4277           case HOST:
4278           case PRINT:
4279           case QUIT:
4280           case REMARK:
4281           case UNDEFINE:
4282           case VARIABLE:
4283           case WHENEVER:
4284           case ATTACH:
4285           case CAST:
4286           case TREAT:
4287           case TRIM:
4288           case LEFT:
4289           case RIGHT:
4290           case BOTH:
4291           case EMPTY:
4292           case MULTISET:
4293           case SUBMULTISET:
4294           case LEADING:
4295           case TRAILING:
4296           case CHAR_CS:
4297           case NCHAR_CS:
4298           case DBTIMEZONE:
4299           case SESSIONTIMEZONE:
4300           case AUTHENTICATED:
4301           case LINK:
4302           case SHARED:
4303           case DIRECTORY:
4304           case USER:
4305           case IDENTIFIER:
4306           case QUOTED_LITERAL:
4307           case SQLDATA_CLASS:
4308           case CUSTOMDATUM_CLASS:
4309           case ORADATA_CLASS:
4310           case JAVA_INTERFACE_CLASS:
4311             ;
4312             break;
4313           default:
4314             jj_la1[40] = jj_gen;
4315             break label_12;
4316           }
4317           switch (jj_nt.kind) {
4318           case REPLACE:
4319           case DEFINER:
4320           case CURRENT_USER:
4321           case SERIALLY_REUSABLE:
4322           case RESTRICT_REFERENCES:
4323           case EXCEPTION_INIT:
4324           case AUTONOMOUS_TRANSACTION:
4325           case LANGUAGE:
4326           case ADD:
4327           case AGGREGATE:
4328           case ALL:
4329           case ALTER:
4330           case AND:
4331           case ANY:
4332           case ARRAY:
4333           case AS:
4334           case ASC:
4335           case AT:
4336           case ATTRIBUTE:
4337           case AUTHID:
4338           case AVG:
4339           case BETWEEN:
4340           case BINARY_INTEGER:
4341           case BODY:
4342           case BOOLEAN:
4343           case BULK:
4344           case BY:
4345           case BYTE:
4346           case CASCADE:
4347           case CASE:
4348           case CHAR:
4349           case CHAR_BASE:
4350           case CHECK:
4351           case CLOSE:
4352           case CLUSTER:
4353           case COALESCE:
4354           case COLLECT:
4355           case COLUMN:
4356           case COMMENT:
4357           case COMMIT:
4358           case COMPRESS:
4359           case CONNECT:
4360           case CONSTANT:
4361           case CONSTRUCTOR:
4362           case CONTINUE:
4363           case CONVERT:
4364           case CREATE:
4365           case CURRENT:
4366           case CURRVAL:
4367           case CURSOR:
4368           case DATA:
4369           case DATE:
4370           case DAY:
4371           case DECLARE:
4372           case DECIMAL:
4373           case _DEFAULT:
4374           case DELETE:
4375           case DESC:
4376           case DISABLE:
4377           case DISTINCT:
4378           case DO:
4379           case DROP:
4380           case EDITIONABLE:
4381           case ELEMENT:
4382           case ELSE:
4383           case ELSIF:
4384           case ENABLE:
4385           case ESCAPE:
4386           case EXCEPT:
4387           case EXCEPTION:
4388           case EXCEPTIONS:
4389           case EXCLUSIVE:
4390           case EXECUTE:
4391           case EXISTS:
4392           case EXIT:
4393           case EXTERNAL:
4394           case EXTENDS:
4395           case EXTRACT:
4396           case FALSE:
4397           case FETCH:
4398           case FINAL:
4399           case FLOAT:
4400           case FOR:
4401           case FORALL:
4402           case FORCE:
4403           case FROM:
4404           case FUNCTION:
4405           case GLOBAL:
4406           case GOTO:
4407           case GROUP:
4408           case HASH:
4409           case HAVING:
4410           case HEAP:
4411           case HOUR:
4412           case IF:
4413           case IMMEDIATE:
4414           case IN:
4415           case INDEX:
4416           case INDICES:
4417           case INDEXTYPE:
4418           case INDICATOR:
4419           case INSERT:
4420           case INSTANTIABLE:
4421           case INTEGER:
4422           case INTERFACE:
4423           case INTERSECT:
4424           case INTERVAL:
4425           case INTO:
4426           case INVALIDATE:
4427           case IS:
4428           case ISOLATION:
4429           case JAVA:
4430           case LEVEL:
4431           case LIKE:
4432           case LIMIT:
4433           case LIMITED:
4434           case LOCK:
4435           case LONG:
4436           case LOOP:
4437           case MAP:
4438           case MAX:
4439           case MEMBER:
4440           case MERGE:
4441           case MIN:
4442           case MINUS:
4443           case MINUTE:
4444           case MLSLABEL:
4445           case MODIFY:
4446           case MOD:
4447           case MODE:
4448           case MONTH:
4449           case NATURAL:
4450           case NATURALN:
4451           case NEW:
4452           case NEXTVAL:
4453           case NO:
4454           case NOCOPY:
4455           case NONEDITIONABLE:
4456           case NOT:
4457           case NOWAIT:
4458           case NULL:
4459           case NULLIF:
4460           case NUMBER:
4461           case BFILE_BASE:
4462           case BLOB_BASE:
4463           case CLOB_BASE:
4464           case DATE_BASE:
4465           case NUMBER_BASE:
4466           case OBJECT:
4467           case OCIROWID:
4468           case OF:
4469           case OID:
4470           case ON:
4471           case OPAQUE:
4472           case OPEN:
4473           case OPERATOR:
4474           case OPTION:
4475           case OR:
4476           case ORDER:
4477           case ORGANIZATION:
4478           case OTHERS:
4479           case OUT:
4480           case OVERRIDING:
4481           case PACKAGE:
4482           case PARTITION:
4483           case PCTFREE:
4484           case PLS_INTEGER:
4485           case POSITIVE:
4486           case POSITIVEN:
4487           case PRAGMA:
4488           case PRESERVE:
4489           case PRIOR:
4490           case PROMPT:
4491           case PRIVATE:
4492           case PROCEDURE:
4493           case PUBLIC:
4494           case RAISE:
4495           case RANGE:
4496           case RAW:
4497           case REAL:
4498           case RECORD:
4499           case REF:
4500           case RELEASE:
4501           case RELIES_ON:
4502           case RENAME:
4503           case RESULT:
4504           case RETURN:
4505           case RETURNING:
4506           case REVERSE:
4507           case ROLLBACK:
4508           case ROW:
4509           case ROWS:
4510           case ROWID:
4511           case ROWNUM:
4512           case ROWTYPE:
4513           case SAVE:
4514           case SAVEPOINT:
4515           case SECOND:
4516           case SELECT:
4517           case SELF:
4518           case SEPARATE:
4519           case SET:
4520           case SHARE:
4521           case SMALLINT:
4522           case SPACE:
4523           case SQL:
4524           case SQLCODE:
4525           case SQLERRM:
4526           case START:
4527           case STATIC:
4528           case STDDEV:
4529           case SUBTYPE:
4530           case SUBSTITUTABLE:
4531           case SUCCESSFUL:
4532           case SUM:
4533           case SYNONYM:
4534           case SYSDATE:
4535           case SYS_REFCURSOR:
4536           case TABLE:
4537           case TEMPORARY:
4538           case THEN:
4539           case TIME:
4540           case TIMESTAMP:
4541           case TIMEZONE_REGION:
4542           case TIMEZONE_ABBR:
4543           case TIMEZONE_MINUTE:
4544           case TIMEZONE_HOUR:
4545           case TO:
4546           case TRANSACTION:
4547           case TRIGGER:
4548           case TRUE:
4549           case TYPE:
4550           case UI:
4551           case UNDER:
4552           case USING:
4553           case WHILE:
4554           case YES:
4555           case SHOW:
4556           case A:
4557           case UPDATE:
4558           case VARCHAR:
4559           case VARCHAR2:
4560           case DOUBLE:
4561           case DEC:
4562           case PRECISION:
4563           case INT:
4564           case NUMERIC:
4565           case SIGNTYPE:
4566           case NCHAR:
4567           case NVARCHAR2:
4568           case STRING:
4569           case UROWID:
4570           case VARRAY:
4571           case VARYING:
4572           case BFILE:
4573           case BLOB:
4574           case CLOB:
4575           case NCLOB:
4576           case YEAR:
4577           case LOCAL:
4578           case WITH:
4579           case ZONE:
4580           case CHARACTER:
4581           case AFTER:
4582           case BEFORE:
4583           case OLD:
4584           case PARENT:
4585           case CC_IF:
4586           case ANALYZE:
4587           case ASSOCIATE:
4588           case AUDIT:
4589           case COMPOUND:
4590           case DATABASE:
4591           case CALL:
4592           case DDL:
4593           case DISASSOCIATE:
4594           case EACH:
4595           case FOLLOWS:
4596           case LOGOFF:
4597           case LOGON:
4598           case NESTED:
4599           case NOAUDIT:
4600           case SCHEMA:
4601           case SERVERERROR:
4602           case SHUTDOWN:
4603           case STARTUP:
4604           case STATEMENT:
4605           case STATISTICS:
4606           case SUSPEND:
4607           case TRUNCATE:
4608           case WRAPPED:
4609           case LIBRARY:
4610           case NAME:
4611           case STRUCT:
4612           case CONTEXT:
4613           case PARAMETERS:
4614           case LENGTH:
4615           case TDO:
4616           case MAXLEN:
4617           case CHARSETID:
4618           case CHARSETFORM:
4619           case ACCEPT:
4620           case ACCESSIBLE:
4621           case COPY:
4622           case DEFINE:
4623           case DISCONNECT:
4624           case HOST:
4625           case PRINT:
4626           case QUIT:
4627           case REMARK:
4628           case UNDEFINE:
4629           case VARIABLE:
4630           case WHENEVER:
4631           case ATTACH:
4632           case CAST:
4633           case TREAT:
4634           case TRIM:
4635           case LEFT:
4636           case RIGHT:
4637           case BOTH:
4638           case EMPTY:
4639           case MULTISET:
4640           case SUBMULTISET:
4641           case LEADING:
4642           case TRAILING:
4643           case CHAR_CS:
4644           case NCHAR_CS:
4645           case DBTIMEZONE:
4646           case SESSIONTIMEZONE:
4647           case AUTHENTICATED:
4648           case LINK:
4649           case SHARED:
4650           case DIRECTORY:
4651           case USER:
4652           case IDENTIFIER:
4653           case QUOTED_LITERAL:
4654           case SQLDATA_CLASS:
4655           case CUSTOMDATUM_CLASS:
4656           case ORADATA_CLASS:
4657           case JAVA_INTERFACE_CLASS:
4658             DeclarativeUnit();
4659             break;
4660           case CC_ERROR:
4661             jj_consume_token(CC_ERROR);
4662             Expression();
4663             jj_consume_token(CC_END);
4664             break;
4665           default:
4666             jj_la1[41] = jj_gen;
4667             jj_consume_token(-1);
4668             throw new ParseException();
4669           }
4670         }
4671       }
4672       jj_consume_token(CC_END);
4673         jjtree.closeNodeScope(jjtn000, true);
4674         jjtc000 = false;
4675         {if (true) return jjtn000 ;}
4676     } catch (Throwable jjte000) {
4677           if (jjtc000) {
4678             jjtree.clearNodeScope(jjtn000);
4679             jjtc000 = false;
4680           } else {
4681             jjtree.popNode();
4682           }
4683           if (jjte000 instanceof RuntimeException) {
4684             {if (true) throw (RuntimeException)jjte000;}
4685           }
4686           if (jjte000 instanceof ParseException) {
4687             {if (true) throw (ParseException)jjte000;}
4688           }
4689           {if (true) throw (Error)jjte000;}
4690     } finally {
4691           if (jjtc000) {
4692             jjtree.closeNodeScope(jjtn000, true);
4693           }
4694     }
4695     throw new Error("Missing return statement in function");
4696   }
4697 
4698 /**
4699  * 2006-05-22 - Matthias Hendler - Printing of custom tag "@deprecated" removed.
4700  *                                 Printing of any custom tag added. Now user can define his own
4701  *								   custom tags which he can evaluate in the XSLT.
4702  *                                 This methode also documents global functions/procedures.
4703  */
4704   final public ASTProgramUnit ProgramUnit() throws ParseException {
4705  /*@bgen(jjtree) ProgramUnit */
4706   ASTProgramUnit jjtn000 = new ASTProgramUnit(this, JJTPROGRAMUNIT);
4707   boolean jjtc000 = true;
4708   jjtree.openNodeScope(jjtn000);
4709     try {
4710       switch (jj_nt.kind) {
4711       case CREATE:
4712         jj_consume_token(CREATE);
4713         switch (jj_nt.kind) {
4714         case OR:
4715           jj_consume_token(OR);
4716           jj_consume_token(REPLACE);
4717           break;
4718         default:
4719           jj_la1[42] = jj_gen;
4720           ;
4721         }
4722         switch (jj_nt.kind) {
4723         case EDITIONABLE:
4724         case NONEDITIONABLE:
4725           switch (jj_nt.kind) {
4726           case EDITIONABLE:
4727             jj_consume_token(EDITIONABLE);
4728             break;
4729           case NONEDITIONABLE:
4730             jj_consume_token(NONEDITIONABLE);
4731             break;
4732           default:
4733             jj_la1[43] = jj_gen;
4734             jj_consume_token(-1);
4735             throw new ParseException();
4736           }
4737           break;
4738         default:
4739           jj_la1[44] = jj_gen;
4740           ;
4741         }
4742         break;
4743       default:
4744         jj_la1[45] = jj_gen;
4745         ;
4746       }
4747       MethodDeclarator();
4748       switch (jj_nt.kind) {
4749       case WRAPPED:
4750         WrappedObject();
4751         break;
4752       case 4:
4753       case AGGREGATE:
4754       case AS:
4755       case AUTHID:
4756       case DETERMINISTIC:
4757       case IS:
4758       case PARALLEL_ENABLE:
4759       case PIPELINED:
4760       case RESULT_CACHE:
4761       case ACCESSIBLE:
4762         label_13:
4763         while (true) {
4764           switch (jj_nt.kind) {
4765           case AUTHID:
4766           case DETERMINISTIC:
4767           case PARALLEL_ENABLE:
4768           case PIPELINED:
4769           case RESULT_CACHE:
4770           case ACCESSIBLE:
4771             ;
4772             break;
4773           default:
4774             jj_la1[46] = jj_gen;
4775             break label_13;
4776           }
4777           switch (jj_nt.kind) {
4778           case AUTHID:
4779             jj_consume_token(AUTHID);
4780             switch (jj_nt.kind) {
4781             case CURRENT_USER:
4782               jj_consume_token(CURRENT_USER);
4783               break;
4784             case DEFINER:
4785               jj_consume_token(DEFINER);
4786               break;
4787             default:
4788               jj_la1[47] = jj_gen;
4789               jj_consume_token(-1);
4790               throw new ParseException();
4791             }
4792             break;
4793           case DETERMINISTIC:
4794             jj_consume_token(DETERMINISTIC);
4795             break;
4796           case ACCESSIBLE:
4797             AccessibleByClause();
4798             break;
4799           case PARALLEL_ENABLE:
4800             jj_consume_token(PARALLEL_ENABLE);
4801             switch (jj_nt.kind) {
4802             case 5:
4803               ParallelClause();
4804               break;
4805             default:
4806               jj_la1[48] = jj_gen;
4807               ;
4808             }
4809             switch (jj_nt.kind) {
4810             case USING:
4811               jj_consume_token(USING);
4812               ID();
4813               switch (jj_nt.kind) {
4814               case 3:
4815                 jj_consume_token(3);
4816                 ID();
4817                 break;
4818               default:
4819                 jj_la1[49] = jj_gen;
4820                 ;
4821               }
4822               break;
4823             default:
4824               jj_la1[50] = jj_gen;
4825               ;
4826             }
4827             break;
4828           case PIPELINED:
4829             jj_consume_token(PIPELINED);
4830             switch (jj_nt.kind) {
4831             case CLUSTER:
4832             case ORDER:
4833             case USING:
4834               switch (jj_nt.kind) {
4835               case USING:
4836                 jj_consume_token(USING);
4837                 ID();
4838                 switch (jj_nt.kind) {
4839                 case 3:
4840                   jj_consume_token(3);
4841                   ID();
4842                   break;
4843                 default:
4844                   jj_la1[51] = jj_gen;
4845                   ;
4846                 }
4847                 break;
4848               case CLUSTER:
4849               case ORDER:
4850                 switch (jj_nt.kind) {
4851                 case ORDER:
4852                   jj_consume_token(ORDER);
4853                   break;
4854                 case CLUSTER:
4855                   jj_consume_token(CLUSTER);
4856                   break;
4857                 default:
4858                   jj_la1[52] = jj_gen;
4859                   jj_consume_token(-1);
4860                   throw new ParseException();
4861                 }
4862                 switch (jj_nt.kind) {
4863                 case REPLACE:
4864                 case DEFINER:
4865                 case CURRENT_USER:
4866                 case SERIALLY_REUSABLE:
4867                 case RESTRICT_REFERENCES:
4868                 case EXCEPTION_INIT:
4869                 case AUTONOMOUS_TRANSACTION:
4870                 case LANGUAGE:
4871                 case ADD:
4872                 case AGGREGATE:
4873                 case ALL:
4874                 case ALTER:
4875                 case AND:
4876                 case ANY:
4877                 case ARRAY:
4878                 case AS:
4879                 case ASC:
4880                 case AT:
4881                 case ATTRIBUTE:
4882                 case AUTHID:
4883                 case AVG:
4884                 case BETWEEN:
4885                 case BINARY_INTEGER:
4886                 case BODY:
4887                 case BOOLEAN:
4888                 case BULK:
4889                 case BY:
4890                 case BYTE:
4891                 case CASCADE:
4892                 case CASE:
4893                 case CHAR:
4894                 case CHAR_BASE:
4895                 case CHECK:
4896                 case CLOSE:
4897                 case CLUSTER:
4898                 case COALESCE:
4899                 case COLLECT:
4900                 case COLUMN:
4901                 case COMMENT:
4902                 case COMMIT:
4903                 case COMPRESS:
4904                 case CONNECT:
4905                 case CONSTANT:
4906                 case CONSTRUCTOR:
4907                 case CONTINUE:
4908                 case CONVERT:
4909                 case CREATE:
4910                 case CURRENT:
4911                 case CURRVAL:
4912                 case CURSOR:
4913                 case DATA:
4914                 case DATE:
4915                 case DAY:
4916                 case DECLARE:
4917                 case DECIMAL:
4918                 case _DEFAULT:
4919                 case DELETE:
4920                 case DESC:
4921                 case DISABLE:
4922                 case DISTINCT:
4923                 case DO:
4924                 case DROP:
4925                 case EDITIONABLE:
4926                 case ELEMENT:
4927                 case ELSE:
4928                 case ELSIF:
4929                 case ENABLE:
4930                 case ESCAPE:
4931                 case EXCEPT:
4932                 case EXCEPTION:
4933                 case EXCEPTIONS:
4934                 case EXCLUSIVE:
4935                 case EXECUTE:
4936                 case EXISTS:
4937                 case EXIT:
4938                 case EXTERNAL:
4939                 case EXTENDS:
4940                 case EXTRACT:
4941                 case FALSE:
4942                 case FETCH:
4943                 case FINAL:
4944                 case FLOAT:
4945                 case FOR:
4946                 case FORALL:
4947                 case FORCE:
4948                 case FROM:
4949                 case FUNCTION:
4950                 case GLOBAL:
4951                 case GOTO:
4952                 case GROUP:
4953                 case HASH:
4954                 case HAVING:
4955                 case HEAP:
4956                 case HOUR:
4957                 case IF:
4958                 case IMMEDIATE:
4959                 case IN:
4960                 case INDEX:
4961                 case INDICES:
4962                 case INDEXTYPE:
4963                 case INDICATOR:
4964                 case INSERT:
4965                 case INSTANTIABLE:
4966                 case INTEGER:
4967                 case INTERFACE:
4968                 case INTERSECT:
4969                 case INTERVAL:
4970                 case INTO:
4971                 case INVALIDATE:
4972                 case IS:
4973                 case ISOLATION:
4974                 case JAVA:
4975                 case LEVEL:
4976                 case LIKE:
4977                 case LIMIT:
4978                 case LIMITED:
4979                 case LOCK:
4980                 case LONG:
4981                 case LOOP:
4982                 case MAP:
4983                 case MAX:
4984                 case MEMBER:
4985                 case MERGE:
4986                 case MIN:
4987                 case MINUS:
4988                 case MINUTE:
4989                 case MLSLABEL:
4990                 case MODIFY:
4991                 case MOD:
4992                 case MODE:
4993                 case MONTH:
4994                 case NATURAL:
4995                 case NATURALN:
4996                 case NEW:
4997                 case NEXTVAL:
4998                 case NO:
4999                 case NOCOPY:
5000                 case NONEDITIONABLE:
5001                 case NOT:
5002                 case NOWAIT:
5003                 case NULL:
5004                 case NULLIF:
5005                 case NUMBER:
5006                 case BFILE_BASE:
5007                 case BLOB_BASE:
5008                 case CLOB_BASE:
5009                 case DATE_BASE:
5010                 case NUMBER_BASE:
5011                 case OBJECT:
5012                 case OCIROWID:
5013                 case OF:
5014                 case OID:
5015                 case ON:
5016                 case OPAQUE:
5017                 case OPEN:
5018                 case OPERATOR:
5019                 case OPTION:
5020                 case OR:
5021                 case ORDER:
5022                 case ORGANIZATION:
5023                 case OTHERS:
5024                 case OUT:
5025                 case OVERRIDING:
5026                 case PACKAGE:
5027                 case PARTITION:
5028                 case PCTFREE:
5029                 case PLS_INTEGER:
5030                 case POSITIVE:
5031                 case POSITIVEN:
5032                 case PRESERVE:
5033                 case PRIOR:
5034                 case PROMPT:
5035                 case PRIVATE:
5036                 case PROCEDURE:
5037                 case PUBLIC:
5038                 case RAISE:
5039                 case RANGE:
5040                 case RAW:
5041                 case REAL:
5042                 case RECORD:
5043                 case REF:
5044                 case RELEASE:
5045                 case RELIES_ON:
5046                 case RENAME:
5047                 case RESULT:
5048                 case RETURN:
5049                 case RETURNING:
5050                 case REVERSE:
5051                 case ROLLBACK:
5052                 case ROW:
5053                 case ROWS:
5054                 case ROWID:
5055                 case ROWNUM:
5056                 case ROWTYPE:
5057                 case SAVE:
5058                 case SAVEPOINT:
5059                 case SECOND:
5060                 case SELECT:
5061                 case SELF:
5062                 case SEPARATE:
5063                 case SET:
5064                 case SHARE:
5065                 case SMALLINT:
5066                 case SPACE:
5067                 case SQL:
5068                 case SQLCODE:
5069                 case SQLERRM:
5070                 case START:
5071                 case STATIC:
5072                 case STDDEV:
5073                 case SUBTYPE:
5074                 case SUBSTITUTABLE:
5075                 case SUCCESSFUL:
5076                 case SUM:
5077                 case SYNONYM:
5078                 case SYSDATE:
5079                 case SYS_REFCURSOR:
5080                 case TABLE:
5081                 case TEMPORARY:
5082                 case THEN:
5083                 case TIME:
5084                 case TIMESTAMP:
5085                 case TIMEZONE_REGION:
5086                 case TIMEZONE_ABBR:
5087                 case TIMEZONE_MINUTE:
5088                 case TIMEZONE_HOUR:
5089                 case TO:
5090                 case TRANSACTION:
5091                 case TRIGGER:
5092                 case TRUE:
5093                 case TYPE:
5094                 case UI:
5095                 case UNDER:
5096                 case USING:
5097                 case WHILE:
5098                 case YES:
5099                 case SHOW:
5100                 case A:
5101                 case UPDATE:
5102                 case VARCHAR:
5103                 case VARCHAR2:
5104                 case DOUBLE:
5105                 case DEC:
5106                 case PRECISION:
5107                 case INT:
5108                 case NUMERIC:
5109                 case SIGNTYPE:
5110                 case NCHAR:
5111                 case NVARCHAR2:
5112                 case STRING:
5113                 case UROWID:
5114                 case VARRAY:
5115                 case VARYING:
5116                 case BFILE:
5117                 case BLOB:
5118                 case CLOB:
5119                 case NCLOB:
5120                 case YEAR:
5121                 case LOCAL:
5122                 case WITH:
5123                 case ZONE:
5124                 case CHARACTER:
5125                 case AFTER:
5126                 case BEFORE:
5127                 case OLD:
5128                 case PARENT:
5129                 case ANALYZE:
5130                 case ASSOCIATE:
5131                 case AUDIT:
5132                 case COMPOUND:
5133                 case DATABASE:
5134                 case CALL:
5135                 case DDL:
5136                 case DISASSOCIATE:
5137                 case EACH:
5138                 case FOLLOWS:
5139                 case LOGOFF:
5140                 case LOGON:
5141                 case NESTED:
5142                 case NOAUDIT:
5143                 case SCHEMA:
5144                 case SERVERERROR:
5145                 case SHUTDOWN:
5146                 case STARTUP:
5147                 case STATEMENT:
5148                 case STATISTICS:
5149                 case SUSPEND:
5150                 case TRUNCATE:
5151                 case WRAPPED:
5152                 case LIBRARY:
5153                 case NAME:
5154                 case STRUCT:
5155                 case CONTEXT:
5156                 case PARAMETERS:
5157                 case LENGTH:
5158                 case TDO:
5159                 case MAXLEN:
5160                 case CHARSETID:
5161                 case CHARSETFORM:
5162                 case ACCEPT:
5163                 case ACCESSIBLE:
5164                 case COPY:
5165                 case DEFINE:
5166                 case DISCONNECT:
5167                 case HOST:
5168                 case PRINT:
5169                 case QUIT:
5170                 case REMARK:
5171                 case UNDEFINE:
5172                 case VARIABLE:
5173                 case WHENEVER:
5174                 case ATTACH:
5175                 case CAST:
5176                 case TREAT:
5177                 case TRIM:
5178                 case LEFT:
5179                 case RIGHT:
5180                 case BOTH:
5181                 case EMPTY:
5182                 case MULTISET:
5183                 case SUBMULTISET:
5184                 case LEADING:
5185                 case TRAILING:
5186                 case CHAR_CS:
5187                 case NCHAR_CS:
5188                 case DBTIMEZONE:
5189                 case SESSIONTIMEZONE:
5190                 case AUTHENTICATED:
5191                 case LINK:
5192                 case SHARED:
5193                 case DIRECTORY:
5194                 case USER:
5195                 case IDENTIFIER:
5196                 case QUOTED_LITERAL:
5197                 case SQLDATA_CLASS:
5198                 case CUSTOMDATUM_CLASS:
5199                 case ORADATA_CLASS:
5200                 case JAVA_INTERFACE_CLASS:
5201                   ID();
5202                   break;
5203                 default:
5204                   jj_la1[53] = jj_gen;
5205                   ;
5206                 }
5207                 jj_consume_token(BY);
5208                 jj_consume_token(5);
5209                 ID();
5210                 label_14:
5211                 while (true) {
5212                   switch (jj_nt.kind) {
5213                   case 6:
5214                     ;
5215                     break;
5216                   default:
5217                     jj_la1[54] = jj_gen;
5218                     break label_14;
5219                   }
5220                   jj_consume_token(6);
5221                   ID();
5222                 }
5223                 jj_consume_token(7);
5224                 break;
5225               default:
5226                 jj_la1[55] = jj_gen;
5227                 jj_consume_token(-1);
5228                 throw new ParseException();
5229               }
5230               break;
5231             default:
5232               jj_la1[56] = jj_gen;
5233               ;
5234             }
5235             break;
5236           case RESULT_CACHE:
5237             jj_consume_token(RESULT_CACHE);
5238             switch (jj_nt.kind) {
5239             case RELIES_ON:
5240               jj_consume_token(RELIES_ON);
5241               jj_consume_token(5);
5242               ID();
5243               switch (jj_nt.kind) {
5244               case 3:
5245                 jj_consume_token(3);
5246                 ID();
5247                 break;
5248               default:
5249                 jj_la1[57] = jj_gen;
5250                 ;
5251               }
5252               label_15:
5253               while (true) {
5254                 switch (jj_nt.kind) {
5255                 case 6:
5256                   ;
5257                   break;
5258                 default:
5259                   jj_la1[58] = jj_gen;
5260                   break label_15;
5261                 }
5262                 jj_consume_token(6);
5263                 ID();
5264                 switch (jj_nt.kind) {
5265                 case 3:
5266                   jj_consume_token(3);
5267                   ID();
5268                   break;
5269                 default:
5270                   jj_la1[59] = jj_gen;
5271                   ;
5272                 }
5273               }
5274               jj_consume_token(7);
5275               break;
5276             default:
5277               jj_la1[60] = jj_gen;
5278               ;
5279             }
5280             break;
5281           default:
5282             jj_la1[61] = jj_gen;
5283             jj_consume_token(-1);
5284             throw new ParseException();
5285           }
5286         }
5287         switch (jj_nt.kind) {
5288         case AGGREGATE:
5289           jj_consume_token(AGGREGATE);
5290           jj_consume_token(USING);
5291           ID();
5292           break;
5293         default:
5294           jj_la1[62] = jj_gen;
5295           ;
5296         }
5297         switch (jj_nt.kind) {
5298         case AS:
5299         case IS:
5300           switch (jj_nt.kind) {
5301           case IS:
5302             jj_consume_token(IS);
5303             break;
5304           case AS:
5305             jj_consume_token(AS);
5306             break;
5307           default:
5308             jj_la1[63] = jj_gen;
5309             jj_consume_token(-1);
5310             throw new ParseException();
5311           }
5312           if (jj_2_21(2)) {
5313             CallSpecTail();
5314           } else {
5315             switch (jj_nt.kind) {
5316             case REPLACE:
5317             case DEFINER:
5318             case CURRENT_USER:
5319             case SERIALLY_REUSABLE:
5320             case RESTRICT_REFERENCES:
5321             case EXCEPTION_INIT:
5322             case AUTONOMOUS_TRANSACTION:
5323             case LANGUAGE:
5324             case ADD:
5325             case AGGREGATE:
5326             case ALL:
5327             case ALTER:
5328             case AND:
5329             case ANY:
5330             case ARRAY:
5331             case AS:
5332             case ASC:
5333             case AT:
5334             case ATTRIBUTE:
5335             case AUTHID:
5336             case AVG:
5337             case BEGIN:
5338             case BETWEEN:
5339             case BINARY_INTEGER:
5340             case BODY:
5341             case BOOLEAN:
5342             case BULK:
5343             case BY:
5344             case BYTE:
5345             case CASCADE:
5346             case CASE:
5347             case CHAR:
5348             case CHAR_BASE:
5349             case CHECK:
5350             case CLOSE:
5351             case CLUSTER:
5352             case COALESCE:
5353             case COLLECT:
5354             case COLUMN:
5355             case COMMENT:
5356             case COMMIT:
5357             case COMPRESS:
5358             case CONNECT:
5359             case CONSTANT:
5360             case CONSTRUCTOR:
5361             case CONTINUE:
5362             case CONVERT:
5363             case CREATE:
5364             case CURRENT:
5365             case CURRVAL:
5366             case CURSOR:
5367             case DATA:
5368             case DATE:
5369             case DAY:
5370             case DECLARE:
5371             case DECIMAL:
5372             case _DEFAULT:
5373             case DELETE:
5374             case DESC:
5375             case DISABLE:
5376             case DISTINCT:
5377             case DO:
5378             case DROP:
5379             case EDITIONABLE:
5380             case ELEMENT:
5381             case ELSE:
5382             case ELSIF:
5383             case ENABLE:
5384             case ESCAPE:
5385             case EXCEPT:
5386             case EXCEPTION:
5387             case EXCEPTIONS:
5388             case EXCLUSIVE:
5389             case EXECUTE:
5390             case EXISTS:
5391             case EXIT:
5392             case EXTERNAL:
5393             case EXTENDS:
5394             case EXTRACT:
5395             case FALSE:
5396             case FETCH:
5397             case FINAL:
5398             case FLOAT:
5399             case FOR:
5400             case FORALL:
5401             case FORCE:
5402             case FROM:
5403             case FUNCTION:
5404             case GLOBAL:
5405             case GOTO:
5406             case GROUP:
5407             case HASH:
5408             case HAVING:
5409             case HEAP:
5410             case HOUR:
5411             case IF:
5412             case IMMEDIATE:
5413             case IN:
5414             case INDEX:
5415             case INDICES:
5416             case INDEXTYPE:
5417             case INDICATOR:
5418             case INSERT:
5419             case INSTANTIABLE:
5420             case INTEGER:
5421             case INTERFACE:
5422             case INTERSECT:
5423             case INTERVAL:
5424             case INTO:
5425             case INVALIDATE:
5426             case IS:
5427             case ISOLATION:
5428             case JAVA:
5429             case LEVEL:
5430             case LIKE:
5431             case LIMIT:
5432             case LIMITED:
5433             case LOCK:
5434             case LONG:
5435             case LOOP:
5436             case MAP:
5437             case MAX:
5438             case MEMBER:
5439             case MERGE:
5440             case MIN:
5441             case MINUS:
5442             case MINUTE:
5443             case MLSLABEL:
5444             case MODIFY:
5445             case MOD:
5446             case MODE:
5447             case MONTH:
5448             case NATURAL:
5449             case NATURALN:
5450             case NEW:
5451             case NEXTVAL:
5452             case NO:
5453             case NOCOPY:
5454             case NONEDITIONABLE:
5455             case NOT:
5456             case NOWAIT:
5457             case NULL:
5458             case NULLIF:
5459             case NUMBER:
5460             case BFILE_BASE:
5461             case BLOB_BASE:
5462             case CLOB_BASE:
5463             case DATE_BASE:
5464             case NUMBER_BASE:
5465             case OBJECT:
5466             case OCIROWID:
5467             case OF:
5468             case OID:
5469             case ON:
5470             case OPAQUE:
5471             case OPEN:
5472             case OPERATOR:
5473             case OPTION:
5474             case OR:
5475             case ORDER:
5476             case ORGANIZATION:
5477             case OTHERS:
5478             case OUT:
5479             case OVERRIDING:
5480             case PACKAGE:
5481             case PARTITION:
5482             case PCTFREE:
5483             case PLS_INTEGER:
5484             case POSITIVE:
5485             case POSITIVEN:
5486             case PRAGMA:
5487             case PRESERVE:
5488             case PRIOR:
5489             case PROMPT:
5490             case PRIVATE:
5491             case PROCEDURE:
5492             case PUBLIC:
5493             case RAISE:
5494             case RANGE:
5495             case RAW:
5496             case REAL:
5497             case RECORD:
5498             case REF:
5499             case RELEASE:
5500             case RELIES_ON:
5501             case RENAME:
5502             case RESULT:
5503             case RETURN:
5504             case RETURNING:
5505             case REVERSE:
5506             case ROLLBACK:
5507             case ROW:
5508             case ROWS:
5509             case ROWID:
5510             case ROWNUM:
5511             case ROWTYPE:
5512             case SAVE:
5513             case SAVEPOINT:
5514             case SECOND:
5515             case SELECT:
5516             case SELF:
5517             case SEPARATE:
5518             case SET:
5519             case SHARE:
5520             case SMALLINT:
5521             case SPACE:
5522             case SQL:
5523             case SQLCODE:
5524             case SQLERRM:
5525             case START:
5526             case STATIC:
5527             case STDDEV:
5528             case SUBTYPE:
5529             case SUBSTITUTABLE:
5530             case SUCCESSFUL:
5531             case SUM:
5532             case SYNONYM:
5533             case SYSDATE:
5534             case SYS_REFCURSOR:
5535             case TABLE:
5536             case TEMPORARY:
5537             case THEN:
5538             case TIME:
5539             case TIMESTAMP:
5540             case TIMEZONE_REGION:
5541             case TIMEZONE_ABBR:
5542             case TIMEZONE_MINUTE:
5543             case TIMEZONE_HOUR:
5544             case TO:
5545             case TRANSACTION:
5546             case TRIGGER:
5547             case TRUE:
5548             case TYPE:
5549             case UI:
5550             case UNDER:
5551             case USING:
5552             case WHILE:
5553             case YES:
5554             case SHOW:
5555             case A:
5556             case UPDATE:
5557             case VARCHAR:
5558             case VARCHAR2:
5559             case DOUBLE:
5560             case DEC:
5561             case PRECISION:
5562             case INT:
5563             case NUMERIC:
5564             case SIGNTYPE:
5565             case NCHAR:
5566             case NVARCHAR2:
5567             case STRING:
5568             case UROWID:
5569             case VARRAY:
5570             case VARYING:
5571             case BFILE:
5572             case BLOB:
5573             case CLOB:
5574             case NCLOB:
5575             case YEAR:
5576             case LOCAL:
5577             case WITH:
5578             case ZONE:
5579             case CHARACTER:
5580             case AFTER:
5581             case BEFORE:
5582             case OLD:
5583             case PARENT:
5584             case CC_IF:
5585             case ANALYZE:
5586             case ASSOCIATE:
5587             case AUDIT:
5588             case COMPOUND:
5589             case DATABASE:
5590             case CALL:
5591             case DDL:
5592             case DISASSOCIATE:
5593             case EACH:
5594             case FOLLOWS:
5595             case LOGOFF:
5596             case LOGON:
5597             case NESTED:
5598             case NOAUDIT:
5599             case SCHEMA:
5600             case SERVERERROR:
5601             case SHUTDOWN:
5602             case STARTUP:
5603             case STATEMENT:
5604             case STATISTICS:
5605             case SUSPEND:
5606             case TRUNCATE:
5607             case WRAPPED:
5608             case LIBRARY:
5609             case NAME:
5610             case STRUCT:
5611             case CONTEXT:
5612             case PARAMETERS:
5613             case LENGTH:
5614             case TDO:
5615             case MAXLEN:
5616             case CHARSETID:
5617             case CHARSETFORM:
5618             case ACCEPT:
5619             case ACCESSIBLE:
5620             case COPY:
5621             case DEFINE:
5622             case DISCONNECT:
5623             case HOST:
5624             case PRINT:
5625             case QUIT:
5626             case REMARK:
5627             case UNDEFINE:
5628             case VARIABLE:
5629             case WHENEVER:
5630             case ATTACH:
5631             case CAST:
5632             case TREAT:
5633             case TRIM:
5634             case LEFT:
5635             case RIGHT:
5636             case BOTH:
5637             case EMPTY:
5638             case MULTISET:
5639             case SUBMULTISET:
5640             case LEADING:
5641             case TRAILING:
5642             case CHAR_CS:
5643             case NCHAR_CS:
5644             case DBTIMEZONE:
5645             case SESSIONTIMEZONE:
5646             case AUTHENTICATED:
5647             case LINK:
5648             case SHARED:
5649             case DIRECTORY:
5650             case USER:
5651             case IDENTIFIER:
5652             case QUOTED_LITERAL:
5653             case SQLDATA_CLASS:
5654             case CUSTOMDATUM_CLASS:
5655             case ORADATA_CLASS:
5656             case JAVA_INTERFACE_CLASS:
5657               DeclarativeSection();
5658               jj_consume_token(BEGIN);
5659               label_16:
5660               while (true) {
5661                 switch (jj_nt.kind) {
5662                 case 5:
5663                 case 16:
5664                 case 17:
5665                 case 21:
5666                 case REPLACE:
5667                 case DEFINER:
5668                 case CURRENT_USER:
5669                 case LANGUAGE:
5670                 case ADD:
5671                 case AGGREGATE:
5672                 case ARRAY:
5673                 case AT:
5674                 case ATTRIBUTE:
5675                 case AUTHID:
5676                 case BEGIN:
5677                 case BODY:
5678                 case BULK:
5679                 case BYTE:
5680                 case CASCADE:
5681                 case CASE:
5682                 case CLOSE:
5683                 case COALESCE:
5684                 case COLLECT:
5685                 case COLUMN:
5686                 case COMMENT:
5687                 case COMMIT:
5688                 case CONSTRUCTOR:
5689                 case CONTINUE:
5690                 case CONVERT:
5691                 case CURRENT:
5692                 case CURSOR:
5693                 case DATA:
5694                 case DATE:
5695                 case DAY:
5696                 case DECLARE:
5697                 case DELETE:
5698                 case DISABLE:
5699                 case EDITIONABLE:
5700                 case ELEMENT:
5701                 case ENABLE:
5702                 case ESCAPE:
5703                 case EXCEPT:
5704                 case EXCEPTIONS:
5705                 case EXECUTE:
5706                 case EXIT:
5707                 case EXTERNAL:
5708                 case EXTENDS:
5709                 case EXTRACT:
5710                 case FALSE:
5711                 case FETCH:
5712                 case FINAL:
5713                 case FOR:
5714                 case FORALL:
5715                 case FORCE:
5716                 case FUNCTION:
5717                 case GLOBAL:
5718                 case GOTO:
5719                 case HASH:
5720                 case HEAP:
5721                 case HOUR:
5722                 case IF:
5723                 case IMMEDIATE:
5724                 case INDICES:
5725                 case INDEXTYPE:
5726                 case INDICATOR:
5727                 case INSERT:
5728                 case INSTANTIABLE:
5729                 case INTERVAL:
5730                 case INVALIDATE:
5731                 case ISOLATION:
5732                 case JAVA:
5733                 case LEVEL:
5734                 case LIMIT:
5735                 case LOCK:
5736                 case LOOP:
5737                 case MAP:
5738                 case MAX:
5739                 case MEMBER:
5740                 case MERGE:
5741                 case MIN:
5742                 case MINUTE:
5743                 case MLSLABEL:
5744                 case MODIFY:
5745                 case MOD:
5746                 case MONTH:
5747                 case NATURAL:
5748                 case NEW:
5749                 case NEW_DOT:
5750                 case NO:
5751                 case NONEDITIONABLE:
5752                 case NOT:
5753                 case NULL:
5754                 case NULLIF:
5755                 case OBJECT:
5756                 case OID:
5757                 case OPAQUE:
5758                 case OPEN:
5759                 case OPERATOR:
5760                 case ORGANIZATION:
5761                 case OTHERS:
5762                 case OVERRIDING:
5763                 case PACKAGE:
5764                 case PARTITION:
5765                 case PIPE:
5766                 case PRESERVE:
5767                 case PRIVATE:
5768                 case PROCEDURE:
5769                 case RAISE:
5770                 case RANGE:
5771                 case RAW:
5772                 case REAL:
5773                 case RECORD:
5774                 case REF:
5775                 case RELEASE:
5776                 case RELIES_ON:
5777                 case RENAME:
5778                 case RESULT:
5779                 case RETURN:
5780                 case RETURNING:
5781                 case REVERSE:
5782                 case ROLLBACK:
5783                 case ROW:
5784                 case ROWS:
5785                 case ROWID:
5786                 case ROWNUM:
5787                 case SAVE:
5788                 case SAVEPOINT:
5789                 case SECOND:
5790                 case SELECT:
5791                 case SELF:
5792                 case SET:
5793                 case SPACE:
5794                 case SQL:
5795                 case SQLCODE:
5796                 case SQLERRM:
5797                 case STATIC:
5798                 case SUBTYPE:
5799                 case SUBSTITUTABLE:
5800                 case SUCCESSFUL:
5801                 case SYSDATE:
5802                 case SYS_REFCURSOR:
5803                 case TEMPORARY:
5804                 case TIME:
5805                 case TIMESTAMP:
5806                 case TIMEZONE_REGION:
5807                 case TIMEZONE_ABBR:
5808                 case TIMEZONE_MINUTE:
5809                 case TIMEZONE_HOUR:
5810                 case TRANSACTION:
5811                 case TRUE:
5812                 case TYPE:
5813                 case UNDER:
5814                 case USING:
5815                 case WHILE:
5816                 case YES:
5817                 case SHOW:
5818                 case A:
5819                 case UPDATE:
5820                 case DOUBLE:
5821                 case DEC:
5822                 case PRECISION:
5823                 case INT:
5824                 case NUMERIC:
5825                 case NCHAR:
5826                 case NVARCHAR2:
5827                 case STRING:
5828                 case UROWID:
5829                 case VARRAY:
5830                 case VARYING:
5831                 case BFILE:
5832                 case BLOB:
5833                 case CLOB:
5834                 case NCLOB:
5835                 case YEAR:
5836                 case LOCAL:
5837                 case WITH:
5838                 case ZONE:
5839                 case CHARACTER:
5840                 case AFTER:
5841                 case BEFORE:
5842                 case OLD:
5843                 case PARENT:
5844                 case CC_IF:
5845                 case CC_ERROR:
5846                 case ANALYZE:
5847                 case ASSOCIATE:
5848                 case AUDIT:
5849                 case COMPOUND:
5850                 case DATABASE:
5851                 case CALL:
5852                 case DDL:
5853                 case DISASSOCIATE:
5854                 case EACH:
5855                 case FOLLOWS:
5856                 case LOGOFF:
5857                 case LOGON:
5858                 case NESTED:
5859                 case NOAUDIT:
5860                 case SCHEMA:
5861                 case SERVERERROR:
5862                 case SHUTDOWN:
5863                 case STARTUP:
5864                 case STATEMENT:
5865                 case STATISTICS:
5866                 case SUSPEND:
5867                 case TRUNCATE:
5868                 case WRAPPED:
5869                 case LIBRARY:
5870                 case NAME:
5871                 case STRUCT:
5872                 case CONTEXT:
5873                 case PARAMETERS:
5874                 case LENGTH:
5875                 case TDO:
5876                 case MAXLEN:
5877                 case CHARSETID:
5878                 case CHARSETFORM:
5879                 case ACCEPT:
5880                 case ACCESSIBLE:
5881                 case COPY:
5882                 case DEFINE:
5883                 case DISCONNECT:
5884                 case HOST:
5885                 case PRINT:
5886                 case QUIT:
5887                 case REMARK:
5888                 case UNDEFINE:
5889                 case VARIABLE:
5890                 case WHENEVER:
5891                 case ATTACH:
5892                 case CAST:
5893                 case TREAT:
5894                 case TRIM:
5895                 case LEFT:
5896                 case RIGHT:
5897                 case BOTH:
5898                 case EMPTY:
5899                 case MULTISET:
5900                 case SUBMULTISET:
5901                 case LEADING:
5902                 case TRAILING:
5903                 case CHAR_CS:
5904                 case NCHAR_CS:
5905                 case DBTIMEZONE:
5906                 case SESSIONTIMEZONE:
5907                 case AUTHENTICATED:
5908                 case LINK:
5909                 case SHARED:
5910                 case DIRECTORY:
5911                 case USER:
5912                 case IDENTIFIER:
5913                 case UNSIGNED_NUMERIC_LITERAL:
5914                 case CHARACTER_LITERAL:
5915                 case STRING_LITERAL:
5916                 case QUOTED_LITERAL:
5917                   ;
5918                   break;
5919                 default:
5920                   jj_la1[64] = jj_gen;
5921                   break label_16;
5922                 }
5923                 Statement();
5924               }
5925               switch (jj_nt.kind) {
5926               case EXCEPTION:
5927                 ExceptionHandler();
5928                 break;
5929               default:
5930                 jj_la1[65] = jj_gen;
5931                 ;
5932               }
5933               jj_consume_token(END);
5934               switch (jj_nt.kind) {
5935               case REPLACE:
5936               case DEFINER:
5937               case CURRENT_USER:
5938               case SERIALLY_REUSABLE:
5939               case RESTRICT_REFERENCES:
5940               case EXCEPTION_INIT:
5941               case AUTONOMOUS_TRANSACTION:
5942               case LANGUAGE:
5943               case ADD:
5944               case AGGREGATE:
5945               case ALL:
5946               case ALTER:
5947               case AND:
5948               case ANY:
5949               case ARRAY:
5950               case AS:
5951               case ASC:
5952               case AT:
5953               case ATTRIBUTE:
5954               case AUTHID:
5955               case AVG:
5956               case BETWEEN:
5957               case BINARY_INTEGER:
5958               case BODY:
5959               case BOOLEAN:
5960               case BULK:
5961               case BY:
5962               case BYTE:
5963               case CASCADE:
5964               case CASE:
5965               case CHAR:
5966               case CHAR_BASE:
5967               case CHECK:
5968               case CLOSE:
5969               case CLUSTER:
5970               case COALESCE:
5971               case COLLECT:
5972               case COLUMN:
5973               case COMMENT:
5974               case COMMIT:
5975               case COMPRESS:
5976               case CONNECT:
5977               case CONSTANT:
5978               case CONSTRUCTOR:
5979               case CONTINUE:
5980               case CONVERT:
5981               case CREATE:
5982               case CURRENT:
5983               case CURRVAL:
5984               case CURSOR:
5985               case DATA:
5986               case DATE:
5987               case DAY:
5988               case DECLARE:
5989               case DECIMAL:
5990               case _DEFAULT:
5991               case DELETE:
5992               case DESC:
5993               case DISABLE:
5994               case DISTINCT:
5995               case DO:
5996               case DROP:
5997               case EDITIONABLE:
5998               case ELEMENT:
5999               case ELSE:
6000               case ELSIF:
6001               case ENABLE:
6002               case ESCAPE:
6003               case EXCEPT:
6004               case EXCEPTION:
6005               case EXCEPTIONS:
6006               case EXCLUSIVE:
6007               case EXECUTE:
6008               case EXISTS:
6009               case EXIT:
6010               case EXTERNAL:
6011               case EXTENDS:
6012               case EXTRACT:
6013               case FALSE:
6014               case FETCH:
6015               case FINAL:
6016               case FLOAT:
6017               case FOR:
6018               case FORALL:
6019               case FORCE:
6020               case FROM:
6021               case FUNCTION:
6022               case GLOBAL:
6023               case GOTO:
6024               case GROUP:
6025               case HASH:
6026               case HAVING:
6027               case HEAP:
6028               case HOUR:
6029               case IF:
6030               case IMMEDIATE:
6031               case IN:
6032               case INDEX:
6033               case INDICES:
6034               case INDEXTYPE:
6035               case INDICATOR:
6036               case INSERT:
6037               case INSTANTIABLE:
6038               case INTEGER:
6039               case INTERFACE:
6040               case INTERSECT:
6041               case INTERVAL:
6042               case INTO:
6043               case INVALIDATE:
6044               case IS:
6045               case ISOLATION:
6046               case JAVA:
6047               case LEVEL:
6048               case LIKE:
6049               case LIMIT:
6050               case LIMITED:
6051               case LOCK:
6052               case LONG:
6053               case LOOP:
6054               case MAP:
6055               case MAX:
6056               case MEMBER:
6057               case MERGE:
6058               case MIN:
6059               case MINUS:
6060               case MINUTE:
6061               case MLSLABEL:
6062               case MODIFY:
6063               case MOD:
6064               case MODE:
6065               case MONTH:
6066               case NATURAL:
6067               case NATURALN:
6068               case NEW:
6069               case NEXTVAL:
6070               case NO:
6071               case NOCOPY:
6072               case NONEDITIONABLE:
6073               case NOT:
6074               case NOWAIT:
6075               case NULL:
6076               case NULLIF:
6077               case NUMBER:
6078               case BFILE_BASE:
6079               case BLOB_BASE:
6080               case CLOB_BASE:
6081               case DATE_BASE:
6082               case NUMBER_BASE:
6083               case OBJECT:
6084               case OCIROWID:
6085               case OF:
6086               case OID:
6087               case ON:
6088               case OPAQUE:
6089               case OPEN:
6090               case OPERATOR:
6091               case OPTION:
6092               case OR:
6093               case ORDER:
6094               case ORGANIZATION:
6095               case OTHERS:
6096               case OUT:
6097               case OVERRIDING:
6098               case PACKAGE:
6099               case PARTITION:
6100               case PCTFREE:
6101               case PLS_INTEGER:
6102               case POSITIVE:
6103               case POSITIVEN:
6104               case PRESERVE:
6105               case PRIOR:
6106               case PROMPT:
6107               case PRIVATE:
6108               case PROCEDURE:
6109               case PUBLIC:
6110               case RAISE:
6111               case RANGE:
6112               case RAW:
6113               case REAL:
6114               case RECORD:
6115               case REF:
6116               case RELEASE:
6117               case RELIES_ON:
6118               case RENAME:
6119               case RESULT:
6120               case RETURN:
6121               case RETURNING:
6122               case REVERSE:
6123               case ROLLBACK:
6124               case ROW:
6125               case ROWS:
6126               case ROWID:
6127               case ROWNUM:
6128               case ROWTYPE:
6129               case SAVE:
6130               case SAVEPOINT:
6131               case SECOND:
6132               case SELECT:
6133               case SELF:
6134               case SEPARATE:
6135               case SET:
6136               case SHARE:
6137               case SMALLINT:
6138               case SPACE:
6139               case SQL:
6140               case SQLCODE:
6141               case SQLERRM:
6142               case START:
6143               case STATIC:
6144               case STDDEV:
6145               case SUBTYPE:
6146               case SUBSTITUTABLE:
6147               case SUCCESSFUL:
6148               case SUM:
6149               case SYNONYM:
6150               case SYSDATE:
6151               case SYS_REFCURSOR:
6152               case TABLE:
6153               case TEMPORARY:
6154               case THEN:
6155               case TIME:
6156               case TIMESTAMP:
6157               case TIMEZONE_REGION:
6158               case TIMEZONE_ABBR:
6159               case TIMEZONE_MINUTE:
6160               case TIMEZONE_HOUR:
6161               case TO:
6162               case TRANSACTION:
6163               case TRIGGER:
6164               case TRUE:
6165               case TYPE:
6166               case UI:
6167               case UNDER:
6168               case USING:
6169               case WHILE:
6170               case YES:
6171               case SHOW:
6172               case A:
6173               case UPDATE:
6174               case VARCHAR:
6175               case VARCHAR2:
6176               case DOUBLE:
6177               case DEC:
6178               case PRECISION:
6179               case INT:
6180               case NUMERIC:
6181               case SIGNTYPE:
6182               case NCHAR:
6183               case NVARCHAR2:
6184               case STRING:
6185               case UROWID:
6186               case VARRAY:
6187               case VARYING:
6188               case BFILE:
6189               case BLOB:
6190               case CLOB:
6191               case NCLOB:
6192               case YEAR:
6193               case LOCAL:
6194               case WITH:
6195               case ZONE:
6196               case CHARACTER:
6197               case AFTER:
6198               case BEFORE:
6199               case OLD:
6200               case PARENT:
6201               case ANALYZE:
6202               case ASSOCIATE:
6203               case AUDIT:
6204               case COMPOUND:
6205               case DATABASE:
6206               case CALL:
6207               case DDL:
6208               case DISASSOCIATE:
6209               case EACH:
6210               case FOLLOWS:
6211               case LOGOFF:
6212               case LOGON:
6213               case NESTED:
6214               case NOAUDIT:
6215               case SCHEMA:
6216               case SERVERERROR:
6217               case SHUTDOWN:
6218               case STARTUP:
6219               case STATEMENT:
6220               case STATISTICS:
6221               case SUSPEND:
6222               case TRUNCATE:
6223               case WRAPPED:
6224               case LIBRARY:
6225               case NAME:
6226               case STRUCT:
6227               case CONTEXT:
6228               case PARAMETERS:
6229               case LENGTH:
6230               case TDO:
6231               case MAXLEN:
6232               case CHARSETID:
6233               case CHARSETFORM:
6234               case ACCEPT:
6235               case ACCESSIBLE:
6236               case COPY:
6237               case DEFINE:
6238               case DISCONNECT:
6239               case HOST:
6240               case PRINT:
6241               case QUIT:
6242               case REMARK:
6243               case UNDEFINE:
6244               case VARIABLE:
6245               case WHENEVER:
6246               case ATTACH:
6247               case CAST:
6248               case TREAT:
6249               case TRIM:
6250               case LEFT:
6251               case RIGHT:
6252               case BOTH:
6253               case EMPTY:
6254               case MULTISET:
6255               case SUBMULTISET:
6256               case LEADING:
6257               case TRAILING:
6258               case CHAR_CS:
6259               case NCHAR_CS:
6260               case DBTIMEZONE:
6261               case SESSIONTIMEZONE:
6262               case AUTHENTICATED:
6263               case LINK:
6264               case SHARED:
6265               case DIRECTORY:
6266               case USER:
6267               case IDENTIFIER:
6268               case QUOTED_LITERAL:
6269               case SQLDATA_CLASS:
6270               case CUSTOMDATUM_CLASS:
6271               case ORADATA_CLASS:
6272               case JAVA_INTERFACE_CLASS:
6273                 ID();
6274                 break;
6275               default:
6276                 jj_la1[66] = jj_gen;
6277                 ;
6278               }
6279               break;
6280             default:
6281               jj_la1[67] = jj_gen;
6282               jj_consume_token(-1);
6283               throw new ParseException();
6284             }
6285           }
6286           break;
6287         default:
6288           jj_la1[68] = jj_gen;
6289           ;
6290         }
6291         jj_consume_token(4);
6292         break;
6293       default:
6294         jj_la1[69] = jj_gen;
6295         jj_consume_token(-1);
6296         throw new ParseException();
6297       }
6298         jjtree.closeNodeScope(jjtn000, true);
6299         jjtc000 = false;
6300         {if (true) return jjtn000 ;}
6301     } catch (Throwable jjte000) {
6302           if (jjtc000) {
6303             jjtree.clearNodeScope(jjtn000);
6304             jjtc000 = false;
6305           } else {
6306             jjtree.popNode();
6307           }
6308           if (jjte000 instanceof RuntimeException) {
6309             {if (true) throw (RuntimeException)jjte000;}
6310           }
6311           if (jjte000 instanceof ParseException) {
6312             {if (true) throw (ParseException)jjte000;}
6313           }
6314           {if (true) throw (Error)jjte000;}
6315     } finally {
6316           if (jjtc000) {
6317             jjtree.closeNodeScope(jjtn000, true);
6318           }
6319     }
6320     throw new Error("Missing return statement in function");
6321   }
6322 
6323   final public ASTObjectNameDeclaration ObjectNameDeclaration() throws ParseException {
6324  /*@bgen(jjtree) ObjectNameDeclaration */
6325  ASTObjectNameDeclaration jjtn000 = new ASTObjectNameDeclaration(this, JJTOBJECTNAMEDECLARATION);
6326  boolean jjtc000 = true;
6327  jjtree.openNodeScope(jjtn000);PLSQLNode schemaName = null, objectName = null ;
6328     try {
6329       if (jj_2_22(2)) {
6330         schemaName = ID();
6331         jj_consume_token(3);
6332       } else {
6333         ;
6334       }
6335       objectName = ID();
6336     jjtn000.setImage(  (null == schemaName) ?  objectName.getImage() : (schemaName.getImage() + "." + objectName.getImage() )  )  ;
6337     jjtree.closeNodeScope(jjtn000, true);
6338     jjtc000 = false;
6339     {if (true) return jjtn000 ;}
6340     } catch (Throwable jjte000) {
6341     if (jjtc000) {
6342       jjtree.clearNodeScope(jjtn000);
6343       jjtc000 = false;
6344     } else {
6345       jjtree.popNode();
6346     }
6347     if (jjte000 instanceof RuntimeException) {
6348       {if (true) throw (RuntimeException)jjte000;}
6349     }
6350     if (jjte000 instanceof ParseException) {
6351       {if (true) throw (ParseException)jjte000;}
6352     }
6353     {if (true) throw (Error)jjte000;}
6354     } finally {
6355     if (jjtc000) {
6356       jjtree.closeNodeScope(jjtn000, true);
6357     }
6358     }
6359     throw new Error("Missing return statement in function");
6360   }
6361 
6362   final public ASTFormalParameter FormalParameter() throws ParseException {
6363  /*@bgen(jjtree) FormalParameter */
6364  ASTFormalParameter jjtn000 = new ASTFormalParameter(this, JJTFORMALPARAMETER);
6365  boolean jjtc000 = true;
6366  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6367     try {
6368       simpleNode = ID();
6369       if (jj_2_25(2)) {
6370         if (jj_2_24(2)) {
6371           switch (jj_nt.kind) {
6372           case OUT:
6373             jj_consume_token(OUT);
6374             break;
6375           case IN:
6376             jj_consume_token(IN);
6377             jj_consume_token(OUT);
6378             break;
6379           default:
6380             jj_la1[70] = jj_gen;
6381             jj_consume_token(-1);
6382             throw new ParseException();
6383           }
6384           if (jj_2_23(2)) {
6385             jj_consume_token(NOCOPY);
6386           } else {
6387             ;
6388           }
6389         } else {
6390           switch (jj_nt.kind) {
6391           case IN:
6392             jj_consume_token(IN);
6393             break;
6394           default:
6395             jj_la1[71] = jj_gen;
6396             jj_consume_token(-1);
6397             throw new ParseException();
6398           }
6399         }
6400       } else {
6401         ;
6402       }
6403       switch (jj_nt.kind) {
6404       case 8:
6405         jj_consume_token(8);
6406         break;
6407       case REPLACE:
6408       case DEFINER:
6409       case CURRENT_USER:
6410       case LANGUAGE:
6411       case ADD:
6412       case AGGREGATE:
6413       case ARRAY:
6414       case AT:
6415       case ATTRIBUTE:
6416       case AUTHID:
6417       case BINARY_INTEGER:
6418       case BODY:
6419       case BOOLEAN:
6420       case BULK:
6421       case BYTE:
6422       case CASCADE:
6423       case CHAR:
6424       case CHAR_BASE:
6425       case CLOSE:
6426       case COALESCE:
6427       case COLLECT:
6428       case COLUMN:
6429       case COMMENT:
6430       case COMMIT:
6431       case CONSTRUCTOR:
6432       case CONTINUE:
6433       case CONVERT:
6434       case CURRENT:
6435       case CURSOR:
6436       case DATA:
6437       case DATE:
6438       case DAY:
6439       case DECIMAL:
6440       case DISABLE:
6441       case EDITIONABLE:
6442       case ELEMENT:
6443       case ENABLE:
6444       case ESCAPE:
6445       case EXCEPT:
6446       case EXCEPTIONS:
6447       case EXIT:
6448       case EXTERNAL:
6449       case EXTENDS:
6450       case EXTRACT:
6451       case FALSE:
6452       case FINAL:
6453       case FLOAT:
6454       case FORCE:
6455       case FUNCTION:
6456       case GLOBAL:
6457       case HASH:
6458       case HEAP:
6459       case HOUR:
6460       case IMMEDIATE:
6461       case INDICES:
6462       case INDEXTYPE:
6463       case INDICATOR:
6464       case INSTANTIABLE:
6465       case INTEGER:
6466       case INTERVAL:
6467       case INVALIDATE:
6468       case ISOLATION:
6469       case JAVA:
6470       case LEVEL:
6471       case LIMIT:
6472       case LONG:
6473       case LOOP:
6474       case MAP:
6475       case MAX:
6476       case MEMBER:
6477       case MERGE:
6478       case MIN:
6479       case MINUTE:
6480       case MLSLABEL:
6481       case MODIFY:
6482       case MOD:
6483       case MONTH:
6484       case NATURAL:
6485       case NATURALN:
6486       case NEW:
6487       case NO:
6488       case NONEDITIONABLE:
6489       case NULLIF:
6490       case NUMBER:
6491       case BFILE_BASE:
6492       case BLOB_BASE:
6493       case CLOB_BASE:
6494       case DATE_BASE:
6495       case NUMBER_BASE:
6496       case OBJECT:
6497       case OID:
6498       case OPAQUE:
6499       case OPEN:
6500       case OPERATOR:
6501       case ORGANIZATION:
6502       case OTHERS:
6503       case OVERRIDING:
6504       case PACKAGE:
6505       case PARTITION:
6506       case PLS_INTEGER:
6507       case POSITIVE:
6508       case POSITIVEN:
6509       case PRESERVE:
6510       case PRIVATE:
6511       case PROCEDURE:
6512       case RANGE:
6513       case RAW:
6514       case REAL:
6515       case RECORD:
6516       case REF:
6517       case RELEASE:
6518       case RELIES_ON:
6519       case RENAME:
6520       case RESULT:
6521       case RETURN:
6522       case RETURNING:
6523       case REVERSE:
6524       case ROLLBACK:
6525       case ROW:
6526       case ROWS:
6527       case ROWID:
6528       case ROWNUM:
6529       case SAVE:
6530       case SAVEPOINT:
6531       case SECOND:
6532       case SELF:
6533       case SET:
6534       case SMALLINT:
6535       case SPACE:
6536       case SQL:
6537       case SQLCODE:
6538       case SQLERRM:
6539       case STATIC:
6540       case SUBTYPE:
6541       case SUBSTITUTABLE:
6542       case SUCCESSFUL:
6543       case SYSDATE:
6544       case SYS_REFCURSOR:
6545       case TEMPORARY:
6546       case TIME:
6547       case TIMESTAMP:
6548       case TIMEZONE_REGION:
6549       case TIMEZONE_ABBR:
6550       case TIMEZONE_MINUTE:
6551       case TIMEZONE_HOUR:
6552       case TRANSACTION:
6553       case TRUE:
6554       case TYPE:
6555       case UNDER:
6556       case USING:
6557       case YES:
6558       case SHOW:
6559       case A:
6560       case VARCHAR:
6561       case VARCHAR2:
6562       case DOUBLE:
6563       case DEC:
6564       case PRECISION:
6565       case INT:
6566       case NUMERIC:
6567       case SIGNTYPE:
6568       case NCHAR:
6569       case NVARCHAR2:
6570       case STRING:
6571       case UROWID:
6572       case VARRAY:
6573       case VARYING:
6574       case BFILE:
6575       case BLOB:
6576       case CLOB:
6577       case NCLOB:
6578       case YEAR:
6579       case LOCAL:
6580       case ZONE:
6581       case CHARACTER:
6582       case AFTER:
6583       case BEFORE:
6584       case OLD:
6585       case PARENT:
6586       case CC_IF:
6587       case ANALYZE:
6588       case ASSOCIATE:
6589       case AUDIT:
6590       case COMPOUND:
6591       case DATABASE:
6592       case CALL:
6593       case DDL:
6594       case DISASSOCIATE:
6595       case EACH:
6596       case FOLLOWS:
6597       case LOGOFF:
6598       case LOGON:
6599       case NESTED:
6600       case NOAUDIT:
6601       case SCHEMA:
6602       case SERVERERROR:
6603       case SHUTDOWN:
6604       case STARTUP:
6605       case STATEMENT:
6606       case STATISTICS:
6607       case SUSPEND:
6608       case TRUNCATE:
6609       case WRAPPED:
6610       case LIBRARY:
6611       case NAME:
6612       case STRUCT:
6613       case CONTEXT:
6614       case PARAMETERS:
6615       case LENGTH:
6616       case TDO:
6617       case MAXLEN:
6618       case CHARSETID:
6619       case CHARSETFORM:
6620       case ACCEPT:
6621       case ACCESSIBLE:
6622       case COPY:
6623       case DEFINE:
6624       case DISCONNECT:
6625       case HOST:
6626       case PRINT:
6627       case QUIT:
6628       case REMARK:
6629       case UNDEFINE:
6630       case VARIABLE:
6631       case WHENEVER:
6632       case ATTACH:
6633       case CAST:
6634       case TREAT:
6635       case TRIM:
6636       case LEFT:
6637       case RIGHT:
6638       case BOTH:
6639       case EMPTY:
6640       case MULTISET:
6641       case SUBMULTISET:
6642       case LEADING:
6643       case TRAILING:
6644       case CHAR_CS:
6645       case NCHAR_CS:
6646       case DBTIMEZONE:
6647       case SESSIONTIMEZONE:
6648       case AUTHENTICATED:
6649       case LINK:
6650       case SHARED:
6651       case DIRECTORY:
6652       case USER:
6653       case IDENTIFIER:
6654       case QUOTED_LITERAL:
6655         Datatype();
6656         break;
6657       default:
6658         jj_la1[72] = jj_gen;
6659         jj_consume_token(-1);
6660         throw new ParseException();
6661       }
6662       switch (jj_nt.kind) {
6663       case 9:
6664       case _DEFAULT:
6665         switch (jj_nt.kind) {
6666         case 9:
6667           jj_consume_token(9);
6668           jj_consume_token(10);
6669           break;
6670         case _DEFAULT:
6671           jj_consume_token(_DEFAULT);
6672           break;
6673         default:
6674           jj_la1[73] = jj_gen;
6675           jj_consume_token(-1);
6676           throw new ParseException();
6677         }
6678         Expression();
6679         break;
6680       default:
6681         jj_la1[74] = jj_gen;
6682         ;
6683       }
6684      jjtree.closeNodeScope(jjtn000, true);
6685      jjtc000 = false;
6686      jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
6687     } catch (Throwable jjte000) {
6688      if (jjtc000) {
6689        jjtree.clearNodeScope(jjtn000);
6690        jjtc000 = false;
6691      } else {
6692        jjtree.popNode();
6693      }
6694      if (jjte000 instanceof RuntimeException) {
6695        {if (true) throw (RuntimeException)jjte000;}
6696      }
6697      if (jjte000 instanceof ParseException) {
6698        {if (true) throw (ParseException)jjte000;}
6699      }
6700      {if (true) throw (Error)jjte000;}
6701     } finally {
6702      if (jjtc000) {
6703        jjtree.closeNodeScope(jjtn000, true);
6704      }
6705     }
6706     throw new Error("Missing return statement in function");
6707   }
6708 
6709   final public ASTMethodDeclaration MethodDeclaration() throws ParseException {
6710  /*@bgen(jjtree) MethodDeclaration */
6711   ASTMethodDeclaration jjtn000 = new ASTMethodDeclaration(this, JJTMETHODDECLARATION);
6712   boolean jjtc000 = true;
6713   jjtree.openNodeScope(jjtn000);
6714     try {
6715       switch (jj_nt.kind) {
6716       case CREATE:
6717       case FUNCTION:
6718       case PROCEDURE:
6719         ProgramUnit();
6720         break;
6721       case CONSTRUCTOR:
6722       case FINAL:
6723       case INSTANTIABLE:
6724       case MAP:
6725       case MEMBER:
6726       case NOT:
6727       case ORDER:
6728       case OVERRIDING:
6729       case STATIC:
6730         TypeMethod();
6731         break;
6732       default:
6733         jj_la1[75] = jj_gen;
6734         jj_consume_token(-1);
6735         throw new ParseException();
6736       }
6737     jjtree.closeNodeScope(jjtn000, true);
6738     jjtc000 = false;
6739     {if (true) return jjtn000 ;}
6740     } catch (Throwable jjte000) {
6741     if (jjtc000) {
6742       jjtree.clearNodeScope(jjtn000);
6743       jjtc000 = false;
6744     } else {
6745       jjtree.popNode();
6746     }
6747     if (jjte000 instanceof RuntimeException) {
6748       {if (true) throw (RuntimeException)jjte000;}
6749     }
6750     if (jjte000 instanceof ParseException) {
6751       {if (true) throw (ParseException)jjte000;}
6752     }
6753     {if (true) throw (Error)jjte000;}
6754     } finally {
6755     if (jjtc000) {
6756       jjtree.closeNodeScope(jjtn000, true);
6757     }
6758     }
6759     throw new Error("Missing return statement in function");
6760   }
6761 
6762   final public ASTMethodDeclarator MethodDeclarator() throws ParseException {
6763  /*@bgen(jjtree) MethodDeclarator */
6764  ASTMethodDeclarator jjtn000 = new ASTMethodDeclarator(this, JJTMETHODDECLARATOR);
6765  boolean jjtc000 = true;
6766  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6767     try {
6768       switch (jj_nt.kind) {
6769       case FUNCTION:
6770         jj_consume_token(FUNCTION);
6771         simpleNode = ObjectNameDeclaration();
6772         switch (jj_nt.kind) {
6773         case 5:
6774           FormalParameters();
6775           break;
6776         default:
6777           jj_la1[76] = jj_gen;
6778           ;
6779         }
6780         Token nextToken;
6781         nextToken = getToken(1); //ReadAhead
6782         if (!nextToken.image.equalsIgnoreCase("WRAPPED")
6783             &&
6784             !nextToken.image.equalsIgnoreCase("RETURN")
6785            )
6786         {
6787           {if (true) throw new ParseException("FUNCTION must RETURN a value or must be WRAPPED : found \u005c""
6788                                               + nextToken.image
6789                                               + "\u005c" at line "+nextToken.beginLine
6790                                               + ", column "+nextToken.beginColumn
6791                                              );}
6792         }
6793         switch (jj_nt.kind) {
6794         case RETURN:
6795           jj_consume_token(RETURN);
6796           Datatype();
6797           break;
6798         default:
6799           jj_la1[77] = jj_gen;
6800           ;
6801         }
6802         break;
6803       case PROCEDURE:
6804         jj_consume_token(PROCEDURE);
6805         simpleNode = ObjectNameDeclaration();
6806         switch (jj_nt.kind) {
6807         case 5:
6808           FormalParameters();
6809           break;
6810         default:
6811           jj_la1[78] = jj_gen;
6812           ;
6813         }
6814         break;
6815       default:
6816         jj_la1[79] = jj_gen;
6817         jj_consume_token(-1);
6818         throw new ParseException();
6819       }
6820     jjtree.closeNodeScope(jjtn000, true);
6821     jjtc000 = false;
6822     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
6823     } catch (Throwable jjte000) {
6824     if (jjtc000) {
6825       jjtree.clearNodeScope(jjtn000);
6826       jjtc000 = false;
6827     } else {
6828       jjtree.popNode();
6829     }
6830     if (jjte000 instanceof RuntimeException) {
6831       {if (true) throw (RuntimeException)jjte000;}
6832     }
6833     if (jjte000 instanceof ParseException) {
6834       {if (true) throw (ParseException)jjte000;}
6835     }
6836     {if (true) throw (Error)jjte000;}
6837     } finally {
6838     if (jjtc000) {
6839       jjtree.closeNodeScope(jjtn000, true);
6840     }
6841     }
6842     throw new Error("Missing return statement in function");
6843   }
6844 
6845   final public ASTFormalParameters FormalParameters() throws ParseException {
6846  /*@bgen(jjtree) FormalParameters */
6847  ASTFormalParameters jjtn000 = new ASTFormalParameters(this, JJTFORMALPARAMETERS);
6848  boolean jjtc000 = true;
6849  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6850  StringBuilder sb = new StringBuilder();
6851     try {
6852       jj_consume_token(5);
6853         sb.append("(");
6854       switch (jj_nt.kind) {
6855       case REPLACE:
6856       case DEFINER:
6857       case CURRENT_USER:
6858       case SERIALLY_REUSABLE:
6859       case RESTRICT_REFERENCES:
6860       case EXCEPTION_INIT:
6861       case AUTONOMOUS_TRANSACTION:
6862       case LANGUAGE:
6863       case ADD:
6864       case AGGREGATE:
6865       case ALL:
6866       case ALTER:
6867       case AND:
6868       case ANY:
6869       case ARRAY:
6870       case AS:
6871       case ASC:
6872       case AT:
6873       case ATTRIBUTE:
6874       case AUTHID:
6875       case AVG:
6876       case BETWEEN:
6877       case BINARY_INTEGER:
6878       case BODY:
6879       case BOOLEAN:
6880       case BULK:
6881       case BY:
6882       case BYTE:
6883       case CASCADE:
6884       case CASE:
6885       case CHAR:
6886       case CHAR_BASE:
6887       case CHECK:
6888       case CLOSE:
6889       case CLUSTER:
6890       case COALESCE:
6891       case COLLECT:
6892       case COLUMN:
6893       case COMMENT:
6894       case COMMIT:
6895       case COMPRESS:
6896       case CONNECT:
6897       case CONSTANT:
6898       case CONSTRUCTOR:
6899       case CONTINUE:
6900       case CONVERT:
6901       case CREATE:
6902       case CURRENT:
6903       case CURRVAL:
6904       case CURSOR:
6905       case DATA:
6906       case DATE:
6907       case DAY:
6908       case DECLARE:
6909       case DECIMAL:
6910       case _DEFAULT:
6911       case DELETE:
6912       case DESC:
6913       case DISABLE:
6914       case DISTINCT:
6915       case DO:
6916       case DROP:
6917       case EDITIONABLE:
6918       case ELEMENT:
6919       case ELSE:
6920       case ELSIF:
6921       case ENABLE:
6922       case ESCAPE:
6923       case EXCEPT:
6924       case EXCEPTION:
6925       case EXCEPTIONS:
6926       case EXCLUSIVE:
6927       case EXECUTE:
6928       case EXISTS:
6929       case EXIT:
6930       case EXTERNAL:
6931       case EXTENDS:
6932       case EXTRACT:
6933       case FALSE:
6934       case FETCH:
6935       case FINAL:
6936       case FLOAT:
6937       case FOR:
6938       case FORALL:
6939       case FORCE:
6940       case FROM:
6941       case FUNCTION:
6942       case GLOBAL:
6943       case GOTO:
6944       case GROUP:
6945       case HASH:
6946       case HAVING:
6947       case HEAP:
6948       case HOUR:
6949       case IF:
6950       case IMMEDIATE:
6951       case IN:
6952       case INDEX:
6953       case INDICES:
6954       case INDEXTYPE:
6955       case INDICATOR:
6956       case INSERT:
6957       case INSTANTIABLE:
6958       case INTEGER:
6959       case INTERFACE:
6960       case INTERSECT:
6961       case INTERVAL:
6962       case INTO:
6963       case INVALIDATE:
6964       case IS:
6965       case ISOLATION:
6966       case JAVA:
6967       case LEVEL:
6968       case LIKE:
6969       case LIMIT:
6970       case LIMITED:
6971       case LOCK:
6972       case LONG:
6973       case LOOP:
6974       case MAP:
6975       case MAX:
6976       case MEMBER:
6977       case MERGE:
6978       case MIN:
6979       case MINUS:
6980       case MINUTE:
6981       case MLSLABEL:
6982       case MODIFY:
6983       case MOD:
6984       case MODE:
6985       case MONTH:
6986       case NATURAL:
6987       case NATURALN:
6988       case NEW:
6989       case NEXTVAL:
6990       case NO:
6991       case NOCOPY:
6992       case NONEDITIONABLE:
6993       case NOT:
6994       case NOWAIT:
6995       case NULL:
6996       case NULLIF:
6997       case NUMBER:
6998       case BFILE_BASE:
6999       case BLOB_BASE:
7000       case CLOB_BASE:
7001       case DATE_BASE:
7002       case NUMBER_BASE:
7003       case OBJECT:
7004       case OCIROWID:
7005       case OF:
7006       case OID:
7007       case ON:
7008       case OPAQUE:
7009       case OPEN:
7010       case OPERATOR:
7011       case OPTION:
7012       case OR:
7013       case ORDER:
7014       case ORGANIZATION:
7015       case OTHERS:
7016       case OUT:
7017       case OVERRIDING:
7018       case PACKAGE:
7019       case PARTITION:
7020       case PCTFREE:
7021       case PLS_INTEGER:
7022       case POSITIVE:
7023       case POSITIVEN:
7024       case PRESERVE:
7025       case PRIOR:
7026       case PROMPT:
7027       case PRIVATE:
7028       case PROCEDURE:
7029       case PUBLIC:
7030       case RAISE:
7031       case RANGE:
7032       case RAW:
7033       case REAL:
7034       case RECORD:
7035       case REF:
7036       case RELEASE:
7037       case RELIES_ON:
7038       case RENAME:
7039       case RESULT:
7040       case RETURN:
7041       case RETURNING:
7042       case REVERSE:
7043       case ROLLBACK:
7044       case ROW:
7045       case ROWS:
7046       case ROWID:
7047       case ROWNUM:
7048       case ROWTYPE:
7049       case SAVE:
7050       case SAVEPOINT:
7051       case SECOND:
7052       case SELECT:
7053       case SELF:
7054       case SEPARATE:
7055       case SET:
7056       case SHARE:
7057       case SMALLINT:
7058       case SPACE:
7059       case SQL:
7060       case SQLCODE:
7061       case SQLERRM:
7062       case START:
7063       case STATIC:
7064       case STDDEV:
7065       case SUBTYPE:
7066       case SUBSTITUTABLE:
7067       case SUCCESSFUL:
7068       case SUM:
7069       case SYNONYM:
7070       case SYSDATE:
7071       case SYS_REFCURSOR:
7072       case TABLE:
7073       case TEMPORARY:
7074       case THEN:
7075       case TIME:
7076       case TIMESTAMP:
7077       case TIMEZONE_REGION:
7078       case TIMEZONE_ABBR:
7079       case TIMEZONE_MINUTE:
7080       case TIMEZONE_HOUR:
7081       case TO:
7082       case TRANSACTION:
7083       case TRIGGER:
7084       case TRUE:
7085       case TYPE:
7086       case UI:
7087       case UNDER:
7088       case USING:
7089       case WHILE:
7090       case YES:
7091       case SHOW:
7092       case A:
7093       case UPDATE:
7094       case VARCHAR:
7095       case VARCHAR2:
7096       case DOUBLE:
7097       case DEC:
7098       case PRECISION:
7099       case INT:
7100       case NUMERIC:
7101       case SIGNTYPE:
7102       case NCHAR:
7103       case NVARCHAR2:
7104       case STRING:
7105       case UROWID:
7106       case VARRAY:
7107       case VARYING:
7108       case BFILE:
7109       case BLOB:
7110       case CLOB:
7111       case NCLOB:
7112       case YEAR:
7113       case LOCAL:
7114       case WITH:
7115       case ZONE:
7116       case CHARACTER:
7117       case AFTER:
7118       case BEFORE:
7119       case OLD:
7120       case PARENT:
7121       case ANALYZE:
7122       case ASSOCIATE:
7123       case AUDIT:
7124       case COMPOUND:
7125       case DATABASE:
7126       case CALL:
7127       case DDL:
7128       case DISASSOCIATE:
7129       case EACH:
7130       case FOLLOWS:
7131       case LOGOFF:
7132       case LOGON:
7133       case NESTED:
7134       case NOAUDIT:
7135       case SCHEMA:
7136       case SERVERERROR:
7137       case SHUTDOWN:
7138       case STARTUP:
7139       case STATEMENT:
7140       case STATISTICS:
7141       case SUSPEND:
7142       case TRUNCATE:
7143       case WRAPPED:
7144       case LIBRARY:
7145       case NAME:
7146       case STRUCT:
7147       case CONTEXT:
7148       case PARAMETERS:
7149       case LENGTH:
7150       case TDO:
7151       case MAXLEN:
7152       case CHARSETID:
7153       case CHARSETFORM:
7154       case ACCEPT:
7155       case ACCESSIBLE:
7156       case COPY:
7157       case DEFINE:
7158       case DISCONNECT:
7159       case HOST:
7160       case PRINT:
7161       case QUIT:
7162       case REMARK:
7163       case UNDEFINE:
7164       case VARIABLE:
7165       case WHENEVER:
7166       case ATTACH:
7167       case CAST:
7168       case TREAT:
7169       case TRIM:
7170       case LEFT:
7171       case RIGHT:
7172       case BOTH:
7173       case EMPTY:
7174       case MULTISET:
7175       case SUBMULTISET:
7176       case LEADING:
7177       case TRAILING:
7178       case CHAR_CS:
7179       case NCHAR_CS:
7180       case DBTIMEZONE:
7181       case SESSIONTIMEZONE:
7182       case AUTHENTICATED:
7183       case LINK:
7184       case SHARED:
7185       case DIRECTORY:
7186       case USER:
7187       case IDENTIFIER:
7188       case QUOTED_LITERAL:
7189       case SQLDATA_CLASS:
7190       case CUSTOMDATUM_CLASS:
7191       case ORADATA_CLASS:
7192       case JAVA_INTERFACE_CLASS:
7193         simpleNode = FormalParameter();
7194                                          sb.append(simpleNode.getImage());
7195         label_17:
7196         while (true) {
7197           switch (jj_nt.kind) {
7198           case 6:
7199             ;
7200             break;
7201           default:
7202             jj_la1[80] = jj_gen;
7203             break label_17;
7204           }
7205           jj_consume_token(6);
7206           simpleNode = FormalParameter();
7207                                                sb.append(","+simpleNode.getImage());
7208         }
7209         break;
7210       default:
7211         jj_la1[81] = jj_gen;
7212         ;
7213       }
7214       jj_consume_token(7);
7215        sb.append(")");
7216     jjtree.closeNodeScope(jjtn000, true);
7217     jjtc000 = false;
7218     jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
7219     } catch (Throwable jjte000) {
7220     if (jjtc000) {
7221       jjtree.clearNodeScope(jjtn000);
7222       jjtc000 = false;
7223     } else {
7224       jjtree.popNode();
7225     }
7226     if (jjte000 instanceof RuntimeException) {
7227       {if (true) throw (RuntimeException)jjte000;}
7228     }
7229     if (jjte000 instanceof ParseException) {
7230       {if (true) throw (ParseException)jjte000;}
7231     }
7232     {if (true) throw (Error)jjte000;}
7233     } finally {
7234     if (jjtc000) {
7235       jjtree.closeNodeScope(jjtn000, true);
7236     }
7237     }
7238     throw new Error("Missing return statement in function");
7239   }
7240 
7241   final public ASTVariableOrConstantDeclarator VariableOrConstantDeclarator() throws ParseException {
7242  /*@bgen(jjtree) VariableOrConstantDeclarator */
7243  ASTVariableOrConstantDeclarator jjtn000 = new ASTVariableOrConstantDeclarator(this, JJTVARIABLEORCONSTANTDECLARATOR);
7244  boolean jjtc000 = true;
7245  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7246  StringBuilder sb = new StringBuilder();
7247     try {
7248       simpleNode = VariableOrConstantDeclaratorId();
7249                                                   sb.append(simpleNode.getImage());
7250       if (jj_2_26(2)) {
7251         jj_consume_token(CONSTANT);
7252                             sb.append(" " + token.image);
7253       } else {
7254         ;
7255       }
7256       simpleNode = Datatype();
7257                                                                                        sb.append(" " + simpleNode.getImage());
7258       switch (jj_nt.kind) {
7259       case NOT:
7260       case NULL:
7261         switch (jj_nt.kind) {
7262         case NOT:
7263           jj_consume_token(NOT);
7264            sb.append(" " + token.image);
7265           break;
7266         default:
7267           jj_la1[82] = jj_gen;
7268           ;
7269         }
7270         jj_consume_token(NULL);
7271                                                     sb.append(" " + token.image);
7272         break;
7273       default:
7274         jj_la1[83] = jj_gen;
7275         ;
7276       }
7277       switch (jj_nt.kind) {
7278       case 9:
7279       case _DEFAULT:
7280         switch (jj_nt.kind) {
7281         case 9:
7282           jj_consume_token(9);
7283           jj_consume_token(10);
7284                sb.append(" :=");
7285           break;
7286         case _DEFAULT:
7287           jj_consume_token(_DEFAULT);
7288                                                sb.append(" " + token.image);
7289           break;
7290         default:
7291           jj_la1[84] = jj_gen;
7292           jj_consume_token(-1);
7293           throw new ParseException();
7294         }
7295         simpleNode = VariableOrConstantInitializer();
7296                                                    sb.append(" " + simpleNode.getImage());
7297         break;
7298       default:
7299         jj_la1[85] = jj_gen;
7300         ;
7301       }
7302     jjtree.closeNodeScope(jjtn000, true);
7303     jjtc000 = false;
7304     jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
7305     } catch (Throwable jjte000) {
7306     if (jjtc000) {
7307       jjtree.clearNodeScope(jjtn000);
7308       jjtc000 = false;
7309     } else {
7310       jjtree.popNode();
7311     }
7312     if (jjte000 instanceof RuntimeException) {
7313       {if (true) throw (RuntimeException)jjte000;}
7314     }
7315     if (jjte000 instanceof ParseException) {
7316       {if (true) throw (ParseException)jjte000;}
7317     }
7318     {if (true) throw (Error)jjte000;}
7319     } finally {
7320     if (jjtc000) {
7321       jjtree.closeNodeScope(jjtn000, true);
7322     }
7323     }
7324     throw new Error("Missing return statement in function");
7325   }
7326 
7327   final public ASTVariableOrConstantDeclaratorId VariableOrConstantDeclaratorId() throws ParseException {
7328  /*@bgen(jjtree) VariableOrConstantDeclaratorId */
7329  ASTVariableOrConstantDeclaratorId jjtn000 = new ASTVariableOrConstantDeclaratorId(this, JJTVARIABLEORCONSTANTDECLARATORID);
7330  boolean jjtc000 = true;
7331  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7332     try {
7333       simpleNode = ID();
7334     jjtree.closeNodeScope(jjtn000, true);
7335     jjtc000 = false;
7336     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
7337     } catch (Throwable jjte000) {
7338     if (jjtc000) {
7339       jjtree.clearNodeScope(jjtn000);
7340       jjtc000 = false;
7341     } else {
7342       jjtree.popNode();
7343     }
7344     if (jjte000 instanceof RuntimeException) {
7345       {if (true) throw (RuntimeException)jjte000;}
7346     }
7347     if (jjte000 instanceof ParseException) {
7348       {if (true) throw (ParseException)jjte000;}
7349     }
7350     {if (true) throw (Error)jjte000;}
7351     } finally {
7352     if (jjtc000) {
7353       jjtree.closeNodeScope(jjtn000, true);
7354     }
7355     }
7356     throw new Error("Missing return statement in function");
7357   }
7358 
7359   final public ASTVariableOrConstantInitializer VariableOrConstantInitializer() throws ParseException {
7360  /*@bgen(jjtree) VariableOrConstantInitializer */
7361  ASTVariableOrConstantInitializer jjtn000 = new ASTVariableOrConstantInitializer(this, JJTVARIABLEORCONSTANTINITIALIZER);
7362  boolean jjtc000 = true;
7363  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7364     try {
7365       simpleNode = Expression();
7366     jjtree.closeNodeScope(jjtn000, true);
7367     jjtc000 = false;
7368     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
7369     } catch (Throwable jjte000) {
7370    if (jjtc000) {
7371      jjtree.clearNodeScope(jjtn000);
7372      jjtc000 = false;
7373    } else {
7374      jjtree.popNode();
7375    }
7376    if (jjte000 instanceof RuntimeException) {
7377      {if (true) throw (RuntimeException)jjte000;}
7378    }
7379    if (jjte000 instanceof ParseException) {
7380      {if (true) throw (ParseException)jjte000;}
7381    }
7382    {if (true) throw (Error)jjte000;}
7383     } finally {
7384    if (jjtc000) {
7385      jjtree.closeNodeScope(jjtn000, true);
7386    }
7387     }
7388     throw new Error("Missing return statement in function");
7389   }
7390 
7391   final public ASTDatatype Datatype() throws ParseException {
7392  /*@bgen(jjtree) Datatype */
7393  ASTDatatype jjtn000 = new ASTDatatype(this, JJTDATATYPE);
7394  boolean jjtc000 = true;
7395  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7396  StringBuilder sb = new StringBuilder();
7397     try {
7398       switch (jj_nt.kind) {
7399       case CC_IF:
7400         // this should be first
7401                         simpleNode = CompilationDataType();
7402                                                     sb.append(simpleNode.getImage());
7403         break;
7404       default:
7405         jj_la1[89] = jj_gen;
7406         if (jj_2_28(2)) {
7407           simpleNode = ScalarDataTypeName();
7408                                                                 sb.append(simpleNode.getImage());
7409         } else {
7410           switch (jj_nt.kind) {
7411           case REPLACE:
7412           case DEFINER:
7413           case CURRENT_USER:
7414           case LANGUAGE:
7415           case ADD:
7416           case AGGREGATE:
7417           case ARRAY:
7418           case AT:
7419           case ATTRIBUTE:
7420           case AUTHID:
7421           case BODY:
7422           case BULK:
7423           case BYTE:
7424           case CASCADE:
7425           case CLOSE:
7426           case COALESCE:
7427           case COLLECT:
7428           case COLUMN:
7429           case COMMENT:
7430           case COMMIT:
7431           case CONSTRUCTOR:
7432           case CONTINUE:
7433           case CONVERT:
7434           case CURRENT:
7435           case CURSOR:
7436           case DATA:
7437           case DAY:
7438           case DISABLE:
7439           case EDITIONABLE:
7440           case ELEMENT:
7441           case ENABLE:
7442           case ESCAPE:
7443           case EXCEPT:
7444           case EXCEPTIONS:
7445           case EXIT:
7446           case EXTERNAL:
7447           case EXTENDS:
7448           case EXTRACT:
7449           case FALSE:
7450           case FINAL:
7451           case FORCE:
7452           case FUNCTION:
7453           case GLOBAL:
7454           case HASH:
7455           case HEAP:
7456           case HOUR:
7457           case IMMEDIATE:
7458           case INDICES:
7459           case INDEXTYPE:
7460           case INDICATOR:
7461           case INSTANTIABLE:
7462           case INTERVAL:
7463           case INVALIDATE:
7464           case ISOLATION:
7465           case JAVA:
7466           case LEVEL:
7467           case LIMIT:
7468           case LOOP:
7469           case MAP:
7470           case MAX:
7471           case MEMBER:
7472           case MERGE:
7473           case MIN:
7474           case MINUTE:
7475           case MLSLABEL:
7476           case MODIFY:
7477           case MOD:
7478           case MONTH:
7479           case NATURAL:
7480           case NEW:
7481           case NO:
7482           case NONEDITIONABLE:
7483           case NULLIF:
7484           case OBJECT:
7485           case OID:
7486           case OPAQUE:
7487           case OPEN:
7488           case OPERATOR:
7489           case ORGANIZATION:
7490           case OTHERS:
7491           case OVERRIDING:
7492           case PACKAGE:
7493           case PARTITION:
7494           case PRESERVE:
7495           case PRIVATE:
7496           case PROCEDURE:
7497           case RANGE:
7498           case RAW:
7499           case REAL:
7500           case RECORD:
7501           case REF:
7502           case RELEASE:
7503           case RELIES_ON:
7504           case RENAME:
7505           case RESULT:
7506           case RETURN:
7507           case RETURNING:
7508           case REVERSE:
7509           case ROLLBACK:
7510           case ROW:
7511           case ROWS:
7512           case ROWID:
7513           case ROWNUM:
7514           case SAVE:
7515           case SAVEPOINT:
7516           case SECOND:
7517           case SELF:
7518           case SET:
7519           case SPACE:
7520           case SQL:
7521           case SQLCODE:
7522           case SQLERRM:
7523           case STATIC:
7524           case SUBTYPE:
7525           case SUBSTITUTABLE:
7526           case SUCCESSFUL:
7527           case SYSDATE:
7528           case SYS_REFCURSOR:
7529           case TEMPORARY:
7530           case TIME:
7531           case TIMESTAMP:
7532           case TIMEZONE_REGION:
7533           case TIMEZONE_ABBR:
7534           case TIMEZONE_MINUTE:
7535           case TIMEZONE_HOUR:
7536           case TRANSACTION:
7537           case TRUE:
7538           case TYPE:
7539           case UNDER:
7540           case USING:
7541           case YES:
7542           case SHOW:
7543           case A:
7544           case DOUBLE:
7545           case DEC:
7546           case PRECISION:
7547           case INT:
7548           case NUMERIC:
7549           case NCHAR:
7550           case NVARCHAR2:
7551           case STRING:
7552           case UROWID:
7553           case VARRAY:
7554           case VARYING:
7555           case BFILE:
7556           case BLOB:
7557           case CLOB:
7558           case NCLOB:
7559           case YEAR:
7560           case LOCAL:
7561           case ZONE:
7562           case CHARACTER:
7563           case AFTER:
7564           case BEFORE:
7565           case OLD:
7566           case PARENT:
7567           case ANALYZE:
7568           case ASSOCIATE:
7569           case AUDIT:
7570           case COMPOUND:
7571           case DATABASE:
7572           case CALL:
7573           case DDL:
7574           case DISASSOCIATE:
7575           case EACH:
7576           case FOLLOWS:
7577           case LOGOFF:
7578           case LOGON:
7579           case NESTED:
7580           case NOAUDIT:
7581           case SCHEMA:
7582           case SERVERERROR:
7583           case SHUTDOWN:
7584           case STARTUP:
7585           case STATEMENT:
7586           case STATISTICS:
7587           case SUSPEND:
7588           case TRUNCATE:
7589           case WRAPPED:
7590           case LIBRARY:
7591           case NAME:
7592           case STRUCT:
7593           case CONTEXT:
7594           case PARAMETERS:
7595           case LENGTH:
7596           case TDO:
7597           case MAXLEN:
7598           case CHARSETID:
7599           case CHARSETFORM:
7600           case ACCEPT:
7601           case ACCESSIBLE:
7602           case COPY:
7603           case DEFINE:
7604           case DISCONNECT:
7605           case HOST:
7606           case PRINT:
7607           case QUIT:
7608           case REMARK:
7609           case UNDEFINE:
7610           case VARIABLE:
7611           case WHENEVER:
7612           case ATTACH:
7613           case CAST:
7614           case TREAT:
7615           case TRIM:
7616           case LEFT:
7617           case RIGHT:
7618           case BOTH:
7619           case EMPTY:
7620           case MULTISET:
7621           case SUBMULTISET:
7622           case LEADING:
7623           case TRAILING:
7624           case CHAR_CS:
7625           case NCHAR_CS:
7626           case DBTIMEZONE:
7627           case SESSIONTIMEZONE:
7628           case AUTHENTICATED:
7629           case LINK:
7630           case SHARED:
7631           case DIRECTORY:
7632           case USER:
7633           case IDENTIFIER:
7634           case QUOTED_LITERAL:
7635             if (jj_2_27(2)) {
7636               jj_consume_token(REF);
7637                                           sb.append(token.image);
7638             } else {
7639               ;
7640             }
7641             simpleNode = QualifiedName();
7642                                                                                                     sb.append(simpleNode.getImage());
7643             switch (jj_nt.kind) {
7644             case 2:
7645               jj_consume_token(2);
7646               simpleNode = QualifiedName();
7647                                                        sb.append("@"+simpleNode.getImage());
7648               break;
7649             default:
7650               jj_la1[86] = jj_gen;
7651               ;
7652             }
7653             switch (jj_nt.kind) {
7654             case 11:
7655               jj_consume_token(11);
7656               switch (jj_nt.kind) {
7657               case TYPE:
7658                 jj_consume_token(TYPE);
7659                 break;
7660               case ROWTYPE:
7661                 jj_consume_token(ROWTYPE);
7662                 break;
7663               default:
7664                 jj_la1[87] = jj_gen;
7665                 jj_consume_token(-1);
7666                 throw new ParseException();
7667               }
7668                                             sb.append("%"+token.image);
7669               break;
7670             default:
7671               jj_la1[88] = jj_gen;
7672               ;
7673             }
7674             break;
7675           default:
7676             jj_la1[90] = jj_gen;
7677             jj_consume_token(-1);
7678             throw new ParseException();
7679           }
7680         }
7681       }
7682           jjtree.closeNodeScope(jjtn000, true);
7683           jjtc000 = false;
7684           jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000;}
7685     } catch (Throwable jjte000) {
7686           if (jjtc000) {
7687             jjtree.clearNodeScope(jjtn000);
7688             jjtc000 = false;
7689           } else {
7690             jjtree.popNode();
7691           }
7692           if (jjte000 instanceof RuntimeException) {
7693             {if (true) throw (RuntimeException)jjte000;}
7694           }
7695           if (jjte000 instanceof ParseException) {
7696             {if (true) throw (ParseException)jjte000;}
7697           }
7698           {if (true) throw (Error)jjte000;}
7699     } finally {
7700           if (jjtc000) {
7701             jjtree.closeNodeScope(jjtn000, true);
7702           }
7703     }
7704     throw new Error("Missing return statement in function");
7705   }
7706 
7707   final public ASTCompilationDataType CompilationDataType() throws ParseException {
7708  /*@bgen(jjtree) CompilationDataType */
7709   ASTCompilationDataType jjtn000 = new ASTCompilationDataType(this, JJTCOMPILATIONDATATYPE);
7710   boolean jjtc000 = true;
7711   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
7712   StringBuilder sb = new StringBuilder() ;
7713     try {
7714       jj_consume_token(CC_IF);
7715                    sb.append(" "); sb.append(token.image) ;
7716       simpleNode = ConditionalOrExpression();
7717                                                  sb.append(" "); sb.append(simpleNode.getImage());
7718       jj_consume_token(CC_THEN);
7719                      sb.append(" "); sb.append(token.image);
7720       simpleNode = Datatype();
7721                                    sb.append(" "); sb.append(simpleNode.getImage());
7722       label_18:
7723       while (true) {
7724         switch (jj_nt.kind) {
7725         case CC_ELSIF:
7726           ;
7727           break;
7728         default:
7729           jj_la1[91] = jj_gen;
7730           break label_18;
7731         }
7732         jj_consume_token(CC_ELSIF);
7733                         sb.append(" "); sb.append(token.image);
7734         simpleNode = ConditionalOrExpression();
7735                                                     sb.append(" "); sb.append(simpleNode.getImage());
7736         jj_consume_token(CC_THEN);
7737                        sb.append(" "); sb.append(token.image);
7738         simpleNode = Datatype();
7739                                      sb.append(" "); sb.append(simpleNode.getImage());
7740       }
7741       label_19:
7742       while (true) {
7743         switch (jj_nt.kind) {
7744         case CC_ELSE:
7745           ;
7746           break;
7747         default:
7748           jj_la1[92] = jj_gen;
7749           break label_19;
7750         }
7751         jj_consume_token(CC_ELSE);
7752                        sb.append(" "); sb.append(token.image);
7753         simpleNode = Datatype();
7754                                       sb.append(" "); sb.append(simpleNode.getImage());
7755       }
7756       jj_consume_token(CC_END);
7757                     sb.append(" "); sb.append(token.image);
7758    jjtree.closeNodeScope(jjtn000, true);
7759    jjtc000 = false;
7760  jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000;}
7761     } catch (Throwable jjte000) {
7762           if (jjtc000) {
7763             jjtree.clearNodeScope(jjtn000);
7764             jjtc000 = false;
7765           } else {
7766             jjtree.popNode();
7767           }
7768           if (jjte000 instanceof RuntimeException) {
7769             {if (true) throw (RuntimeException)jjte000;}
7770           }
7771           if (jjte000 instanceof ParseException) {
7772             {if (true) throw (ParseException)jjte000;}
7773           }
7774           {if (true) throw (Error)jjte000;}
7775     } finally {
7776           if (jjtc000) {
7777             jjtree.closeNodeScope(jjtn000, true);
7778           }
7779     }
7780     throw new Error("Missing return statement in function");
7781   }
7782 
7783   final public ASTCollectionTypeName CollectionTypeName() throws ParseException {
7784  /*@bgen(jjtree) CollectionTypeName */
7785   ASTCollectionTypeName jjtn000 = new ASTCollectionTypeName(this, JJTCOLLECTIONTYPENAME);
7786   boolean jjtc000 = true;
7787   jjtree.openNodeScope(jjtn000);PLSQLNode size=null, precision=null;
7788         StringBuilder sb = new StringBuilder();
7789     try {
7790       switch (jj_nt.kind) {
7791       case TABLE:
7792         jj_consume_token(TABLE);
7793         break;
7794       case VARRAY:
7795         jj_consume_token(VARRAY);
7796         break;
7797       case VARYING:
7798         jj_consume_token(VARYING);
7799         jj_consume_token(ARRAY);
7800                                                 sb.append( "VARYING ARRAY") ;
7801         break;
7802       default:
7803         jj_la1[93] = jj_gen;
7804         jj_consume_token(-1);
7805         throw new ParseException();
7806       }
7807       if (sb.length() ==  0) {
7808         sb.append(token.toString());
7809       }
7810       if (jj_2_29(2)) {
7811         jj_consume_token(5);
7812         size = NumericLiteral();
7813                                                  sb.append( "(" + size);
7814         switch (jj_nt.kind) {
7815         case 6:
7816           jj_consume_token(6);
7817           precision = NumericLiteral();
7818                                                  sb.append( "," + precision);
7819           break;
7820         default:
7821           jj_la1[94] = jj_gen;
7822           ;
7823         }
7824         switch (jj_nt.kind) {
7825         case CHAR:
7826           jj_consume_token(CHAR);
7827                           sb.append( " CHAR") ;
7828           break;
7829         default:
7830           jj_la1[95] = jj_gen;
7831           ;
7832         }
7833         switch (jj_nt.kind) {
7834         case BYTE:
7835           jj_consume_token(BYTE);
7836                           sb.append( " BYTE") ;
7837           break;
7838         default:
7839           jj_la1[96] = jj_gen;
7840           ;
7841         }
7842         jj_consume_token(7);
7843              sb.append( ")");
7844       } else {
7845         ;
7846       }
7847         jjtree.closeNodeScope(jjtn000, true);
7848         jjtc000 = false;
7849         jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000;}
7850     } catch (Throwable jjte000) {
7851        if (jjtc000) {
7852          jjtree.clearNodeScope(jjtn000);
7853          jjtc000 = false;
7854        } else {
7855          jjtree.popNode();
7856        }
7857        if (jjte000 instanceof RuntimeException) {
7858          {if (true) throw (RuntimeException)jjte000;}
7859        }
7860        if (jjte000 instanceof ParseException) {
7861          {if (true) throw (ParseException)jjte000;}
7862        }
7863        {if (true) throw (Error)jjte000;}
7864     } finally {
7865        if (jjtc000) {
7866          jjtree.closeNodeScope(jjtn000, true);
7867        }
7868     }
7869     throw new Error("Missing return statement in function");
7870   }
7871 
7872   final public ASTScalarDataTypeName ScalarDataTypeName() throws ParseException {
7873  /*@bgen(jjtree) ScalarDataTypeName */
7874   ASTScalarDataTypeName jjtn000 = new ASTScalarDataTypeName(this, JJTSCALARDATATYPENAME);
7875   boolean jjtc000 = true;
7876   jjtree.openNodeScope(jjtn000);PLSQLNode size=null, precision=null ;
7877         StringBuilder name = new StringBuilder();
7878         PLSQLNode characterSet = null;
7879     try {
7880       switch (jj_nt.kind) {
7881       case BFILE_BASE:
7882         jj_consume_token(BFILE_BASE);
7883         break;
7884       case BLOB_BASE:
7885         jj_consume_token(BLOB_BASE);
7886         break;
7887       case CHAR_BASE:
7888         jj_consume_token(CHAR_BASE);
7889         break;
7890       case CLOB_BASE:
7891         jj_consume_token(CLOB_BASE);
7892         break;
7893       case DATE_BASE:
7894         jj_consume_token(DATE_BASE);
7895         break;
7896       case NUMBER_BASE:
7897         jj_consume_token(NUMBER_BASE);
7898         break;
7899       case BINARY_INTEGER:
7900         jj_consume_token(BINARY_INTEGER);
7901         break;
7902       case DEC:
7903         jj_consume_token(DEC);
7904         break;
7905       case DECIMAL:
7906         jj_consume_token(DECIMAL);
7907         break;
7908       case DOUBLE:
7909         jj_consume_token(DOUBLE);
7910         jj_consume_token(PRECISION);
7911                                                                      name.append("DOUBLE PRECISION");
7912         break;
7913       case FLOAT:
7914         jj_consume_token(FLOAT);
7915         break;
7916       case INT:
7917         jj_consume_token(INT);
7918         break;
7919       case INTEGER:
7920         jj_consume_token(INTEGER);
7921         break;
7922       case NATURAL:
7923         jj_consume_token(NATURAL);
7924         break;
7925       case NATURALN:
7926         jj_consume_token(NATURALN);
7927         break;
7928       case NUMBER:
7929         jj_consume_token(NUMBER);
7930         break;
7931       case NUMERIC:
7932         jj_consume_token(NUMERIC);
7933         break;
7934       case PLS_INTEGER:
7935         jj_consume_token(PLS_INTEGER);
7936         break;
7937       case POSITIVE:
7938         jj_consume_token(POSITIVE);
7939         break;
7940       case POSITIVEN:
7941         jj_consume_token(POSITIVEN);
7942         break;
7943       case REAL:
7944         jj_consume_token(REAL);
7945         break;
7946       case SIGNTYPE:
7947         jj_consume_token(SIGNTYPE);
7948         break;
7949       case SMALLINT:
7950         jj_consume_token(SMALLINT);
7951         break;
7952       case CHAR:
7953       case LONG:
7954       case RAW:
7955       case ROWID:
7956       case VARCHAR:
7957       case VARCHAR2:
7958       case NCHAR:
7959       case NVARCHAR2:
7960       case STRING:
7961       case UROWID:
7962       case CLOB:
7963       case NCLOB:
7964       case CHARACTER:
7965         switch (jj_nt.kind) {
7966         case CHAR:
7967           jj_consume_token(CHAR);
7968           break;
7969         case CHARACTER:
7970           jj_consume_token(CHARACTER);
7971           break;
7972         default:
7973           jj_la1[97] = jj_gen;
7974           if (jj_2_30(2)) {
7975             jj_consume_token(LONG);
7976             jj_consume_token(RAW);
7977                                        name.append("LONG RAW");
7978           } else {
7979             switch (jj_nt.kind) {
7980             case LONG:
7981               jj_consume_token(LONG);
7982               break;
7983             case NCHAR:
7984               jj_consume_token(NCHAR);
7985               break;
7986             case NVARCHAR2:
7987               jj_consume_token(NVARCHAR2);
7988               break;
7989             case RAW:
7990               jj_consume_token(RAW);
7991               break;
7992             case ROWID:
7993               jj_consume_token(ROWID);
7994               break;
7995             case STRING:
7996               jj_consume_token(STRING);
7997               break;
7998             case UROWID:
7999               jj_consume_token(UROWID);
8000               break;
8001             case VARCHAR:
8002               jj_consume_token(VARCHAR);
8003               break;
8004             case VARCHAR2:
8005               jj_consume_token(VARCHAR2);
8006               break;
8007             case CLOB:
8008               jj_consume_token(CLOB);
8009               break;
8010             case NCLOB:
8011               jj_consume_token(NCLOB);
8012               break;
8013             default:
8014               jj_la1[98] = jj_gen;
8015               jj_consume_token(-1);
8016               throw new ParseException();
8017             }
8018           }
8019         }
8020         break;
8021       case BOOLEAN:
8022         jj_consume_token(BOOLEAN);
8023         break;
8024       case BFILE:
8025         jj_consume_token(BFILE);
8026         break;
8027       case BLOB:
8028         jj_consume_token(BLOB);
8029         break;
8030       case SYS_REFCURSOR:
8031         jj_consume_token(SYS_REFCURSOR);
8032         break;
8033       case REF:
8034         jj_consume_token(REF);
8035         jj_consume_token(CURSOR);
8036                         name.append("REF CURSOR");
8037         break;
8038       case DATE:
8039         jj_consume_token(DATE);
8040         break;
8041       default:
8042         jj_la1[99] = jj_gen;
8043         if (jj_2_31(2)) {
8044           jj_consume_token(INTERVAL);
8045           jj_consume_token(YEAR);
8046                                         name.append("INTERVAL YEAR");
8047         } else if (jj_2_32(2)) {
8048           jj_consume_token(INTERVAL);
8049           jj_consume_token(DAY);
8050                                        name.append("INTERVAL DAY");
8051         } else {
8052           switch (jj_nt.kind) {
8053           case TIME:
8054             jj_consume_token(TIME);
8055             break;
8056           case TIMESTAMP:
8057             jj_consume_token(TIMESTAMP);
8058             break;
8059           case SELF:
8060             jj_consume_token(SELF);
8061             jj_consume_token(AS);
8062             jj_consume_token(RESULT);
8063                              name.append("SELF AS RESULT");
8064             break;
8065           default:
8066             jj_la1[100] = jj_gen;
8067             jj_consume_token(-1);
8068             throw new ParseException();
8069           }
8070         }
8071       }
8072       if (name.length() == 0 ) {
8073         name.append(token.toString());
8074       }
8075       if (jj_2_33(2)) {
8076         jj_consume_token(5);
8077         size = NumericLiteral();
8078                                                  name.append("("); name.append(size.getImage()) ;
8079         switch (jj_nt.kind) {
8080         case 6:
8081           jj_consume_token(6);
8082           precision = UnaryExpression(true);
8083                                                       name.append(",") ; name.append(precision.getImage()) ;
8084           break;
8085         default:
8086           jj_la1[101] = jj_gen;
8087           ;
8088         }
8089         switch (jj_nt.kind) {
8090         case CHAR:
8091           jj_consume_token(CHAR);
8092                           name.append(" CHAR") ;
8093           break;
8094         default:
8095           jj_la1[102] = jj_gen;
8096           ;
8097         }
8098         switch (jj_nt.kind) {
8099         case BYTE:
8100           jj_consume_token(BYTE);
8101                           name.append(" BYTE") ;
8102           break;
8103         default:
8104           jj_la1[103] = jj_gen;
8105           ;
8106         }
8107         jj_consume_token(7);
8108              name.append( ")") ;
8109       } else {
8110         ;
8111       }
8112       switch (jj_nt.kind) {
8113       case TO:
8114       case WITH:
8115       case CHARACTER:
8116         switch (jj_nt.kind) {
8117         case CHARACTER:
8118           jj_consume_token(CHARACTER);
8119           jj_consume_token(SET);
8120           characterSet = Name();
8121                                               name.append( " CHARACTER SET ") ;  name.append(characterSet.getImage()) ;
8122           break;
8123         default:
8124           jj_la1[104] = jj_gen;
8125           if (jj_2_35(4)) {
8126             jj_consume_token(WITH);
8127             jj_consume_token(LOCAL);
8128             jj_consume_token(TIME);
8129             jj_consume_token(ZONE);
8130                                              name.append(" WITH LOCAL TIME ZONE");
8131           } else if (jj_2_36(3)) {
8132             jj_consume_token(WITH);
8133             jj_consume_token(TIME);
8134             jj_consume_token(ZONE);
8135                                       name.append( " WITH TIME ZONE");
8136           } else if (jj_2_37(2)) {
8137             jj_consume_token(TO);
8138             jj_consume_token(MONTH);
8139                                name.append( " TO MONTH");
8140           } else if (jj_2_38(2)) {
8141             jj_consume_token(TO);
8142             jj_consume_token(SECOND);
8143                                 name.append( " TO SECOND");
8144             if (jj_2_34(2)) {
8145               jj_consume_token(5);
8146               precision = NumericLiteral();
8147                                                                        name.append( "(" + precision) ;
8148               jj_consume_token(7);
8149                                              name.append( ")");
8150             } else {
8151               ;
8152             }
8153           } else {
8154             jj_consume_token(-1);
8155             throw new ParseException();
8156           }
8157         }
8158         break;
8159       default:
8160         jj_la1[105] = jj_gen;
8161         ;
8162       }
8163         jjtree.closeNodeScope(jjtn000, true);
8164         jjtc000 = false;
8165         jjtn000.setImage(name.toString()) ;  {if (true) return jjtn000;}
8166     } catch (Throwable jjte000) {
8167           if (jjtc000) {
8168             jjtree.clearNodeScope(jjtn000);
8169             jjtc000 = false;
8170           } else {
8171             jjtree.popNode();
8172           }
8173           if (jjte000 instanceof RuntimeException) {
8174             {if (true) throw (RuntimeException)jjte000;}
8175           }
8176           if (jjte000 instanceof ParseException) {
8177             {if (true) throw (ParseException)jjte000;}
8178           }
8179           {if (true) throw (Error)jjte000;}
8180     } finally {
8181           if (jjtc000) {
8182             jjtree.closeNodeScope(jjtn000, true);
8183           }
8184     }
8185     throw new Error("Missing return statement in function");
8186   }
8187 
8188   final public ASTDateTimeLiteral DateTimeLiteral() throws ParseException {
8189  /*@bgen(jjtree) DateTimeLiteral */
8190  ASTDateTimeLiteral jjtn000 = new ASTDateTimeLiteral(this, JJTDATETIMELITERAL);
8191  boolean jjtc000 = true;
8192  jjtree.openNodeScope(jjtn000);Token t = null ;
8193  PLSQLNode simpleNode = null ;
8194  StringBuilder sb = new StringBuilder() ;
8195     try {
8196       switch (jj_nt.kind) {
8197       case INTERVAL:
8198         jj_consume_token(INTERVAL);
8199         break;
8200       case TIMESTAMP:
8201         jj_consume_token(TIMESTAMP);
8202         break;
8203       case DATE:
8204         jj_consume_token(DATE);
8205         break;
8206       default:
8207         jj_la1[106] = jj_gen;
8208         jj_consume_token(-1);
8209         throw new ParseException();
8210       }
8211           sb.append(token.image);
8212       switch (jj_nt.kind) {
8213       case CHARACTER_LITERAL:
8214         jj_consume_token(CHARACTER_LITERAL);
8215                                 sb.append(" ");  sb.append(token.image);
8216         break;
8217       case STRING_LITERAL:
8218         simpleNode = StringLiteral();
8219                                         sb.append(" ");  sb.append(simpleNode.getImage());
8220         break;
8221       default:
8222         jj_la1[107] = jj_gen;
8223         jj_consume_token(-1);
8224         throw new ParseException();
8225       }
8226       switch (jj_nt.kind) {
8227       case DAY:
8228       case HOUR:
8229       case MINUTE:
8230       case MONTH:
8231       case SECOND:
8232       case YEAR:
8233         switch (jj_nt.kind) {
8234         case YEAR:
8235           jj_consume_token(YEAR);
8236           break;
8237         case MONTH:
8238           jj_consume_token(MONTH);
8239           break;
8240         case DAY:
8241           jj_consume_token(DAY);
8242           break;
8243         case HOUR:
8244           jj_consume_token(HOUR);
8245           break;
8246         case MINUTE:
8247           jj_consume_token(MINUTE);
8248           break;
8249         case SECOND:
8250           jj_consume_token(SECOND);
8251           break;
8252         default:
8253           jj_la1[108] = jj_gen;
8254           jj_consume_token(-1);
8255           throw new ParseException();
8256         }
8257         break;
8258       default:
8259         jj_la1[109] = jj_gen;
8260         ;
8261       }
8262            if (null != t)
8263            {
8264             sb.append(" ");  sb.append(token.image);
8265             t = null;
8266            }
8267       if (jj_2_39(2)) {
8268         jj_consume_token(5);
8269         simpleNode = NumericLiteral();
8270                                                            sb.append("(");  sb.append(simpleNode.getImage());
8271         jj_consume_token(7);
8272                sb.append("}");
8273       } else {
8274         ;
8275       }
8276       switch (jj_nt.kind) {
8277       case TO:
8278       case WITH:
8279         switch (jj_nt.kind) {
8280         case WITH:
8281           jj_consume_token(WITH);
8282               sb.append(" "); sb.append(token.toString()) ;
8283           switch (jj_nt.kind) {
8284           case LOCAL:
8285             jj_consume_token(LOCAL);
8286                   sb.append(" "); sb.append(token.toString()) ;
8287             break;
8288           default:
8289             jj_la1[110] = jj_gen;
8290             ;
8291           }
8292           jj_consume_token(TIME);
8293           jj_consume_token(ZONE);
8294                     sb.append(" "); sb.append("TIME ZONE") ;
8295           break;
8296         case TO:
8297           jj_consume_token(TO);
8298             sb.append(" "); sb.append(token.toString()) ;
8299           switch (jj_nt.kind) {
8300           case YEAR:
8301             jj_consume_token(YEAR);
8302             break;
8303           case MONTH:
8304             jj_consume_token(MONTH);
8305             break;
8306           case DAY:
8307             jj_consume_token(DAY);
8308             break;
8309           case HOUR:
8310             jj_consume_token(HOUR);
8311             break;
8312           case MINUTE:
8313             jj_consume_token(MINUTE);
8314             break;
8315           case SECOND:
8316             jj_consume_token(SECOND);
8317             break;
8318           default:
8319             jj_la1[111] = jj_gen;
8320             jj_consume_token(-1);
8321             throw new ParseException();
8322           }
8323           sb.append(token.image);
8324           if (jj_2_40(2)) {
8325             jj_consume_token(5);
8326             simpleNode = NumericLiteral();
8327                                                            sb.append("(");  sb.append(simpleNode.getImage());
8328             jj_consume_token(7);
8329                 sb.append("}");
8330           } else {
8331             ;
8332           }
8333           break;
8334         default:
8335           jj_la1[112] = jj_gen;
8336           jj_consume_token(-1);
8337           throw new ParseException();
8338         }
8339         break;
8340       default:
8341         jj_la1[113] = jj_gen;
8342         ;
8343       }
8344      jjtree.closeNodeScope(jjtn000, true);
8345      jjtc000 = false;
8346     jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
8347     } catch (Throwable jjte000) {
8348       if (jjtc000) {
8349         jjtree.clearNodeScope(jjtn000);
8350         jjtc000 = false;
8351       } else {
8352         jjtree.popNode();
8353       }
8354       if (jjte000 instanceof RuntimeException) {
8355         {if (true) throw (RuntimeException)jjte000;}
8356       }
8357       if (jjte000 instanceof ParseException) {
8358         {if (true) throw (ParseException)jjte000;}
8359       }
8360       {if (true) throw (Error)jjte000;}
8361     } finally {
8362       if (jjtc000) {
8363         jjtree.closeNodeScope(jjtn000, true);
8364       }
8365     }
8366     throw new Error("Missing return statement in function");
8367   }
8368 
8369   final public ASTExceptionHandler ExceptionHandler() throws ParseException {
8370  /*@bgen(jjtree) ExceptionHandler */
8371   ASTExceptionHandler jjtn000 = new ASTExceptionHandler(this, JJTEXCEPTIONHANDLER);
8372   boolean jjtc000 = true;
8373   jjtree.openNodeScope(jjtn000);
8374     try {
8375       jj_consume_token(EXCEPTION);
8376       label_20:
8377       while (true) {
8378         if (jj_2_41(2)) {
8379           ;
8380         } else {
8381           break label_20;
8382         }
8383         jj_consume_token(WHEN);
8384         QualifiedName();
8385         label_21:
8386         while (true) {
8387           switch (jj_nt.kind) {
8388           case OR:
8389             ;
8390             break;
8391           default:
8392             jj_la1[114] = jj_gen;
8393             break label_21;
8394           }
8395           jj_consume_token(OR);
8396           QualifiedName();
8397         }
8398         jj_consume_token(THEN);
8399         label_22:
8400         while (true) {
8401           Statement();
8402           switch (jj_nt.kind) {
8403           case 5:
8404           case 16:
8405           case 17:
8406           case 21:
8407           case REPLACE:
8408           case DEFINER:
8409           case CURRENT_USER:
8410           case LANGUAGE:
8411           case ADD:
8412           case AGGREGATE:
8413           case ARRAY:
8414           case AT:
8415           case ATTRIBUTE:
8416           case AUTHID:
8417           case BEGIN:
8418           case BODY:
8419           case BULK:
8420           case BYTE:
8421           case CASCADE:
8422           case CASE:
8423           case CLOSE:
8424           case COALESCE:
8425           case COLLECT:
8426           case COLUMN:
8427           case COMMENT:
8428           case COMMIT:
8429           case CONSTRUCTOR:
8430           case CONTINUE:
8431           case CONVERT:
8432           case CURRENT:
8433           case CURSOR:
8434           case DATA:
8435           case DATE:
8436           case DAY:
8437           case DECLARE:
8438           case DELETE:
8439           case DISABLE:
8440           case EDITIONABLE:
8441           case ELEMENT:
8442           case ENABLE:
8443           case ESCAPE:
8444           case EXCEPT:
8445           case EXCEPTIONS:
8446           case EXECUTE:
8447           case EXIT:
8448           case EXTERNAL:
8449           case EXTENDS:
8450           case EXTRACT:
8451           case FALSE:
8452           case FETCH:
8453           case FINAL:
8454           case FOR:
8455           case FORALL:
8456           case FORCE:
8457           case FUNCTION:
8458           case GLOBAL:
8459           case GOTO:
8460           case HASH:
8461           case HEAP:
8462           case HOUR:
8463           case IF:
8464           case IMMEDIATE:
8465           case INDICES:
8466           case INDEXTYPE:
8467           case INDICATOR:
8468           case INSERT:
8469           case INSTANTIABLE:
8470           case INTERVAL:
8471           case INVALIDATE:
8472           case ISOLATION:
8473           case JAVA:
8474           case LEVEL:
8475           case LIMIT:
8476           case LOCK:
8477           case LOOP:
8478           case MAP:
8479           case MAX:
8480           case MEMBER:
8481           case MERGE:
8482           case MIN:
8483           case MINUTE:
8484           case MLSLABEL:
8485           case MODIFY:
8486           case MOD:
8487           case MONTH:
8488           case NATURAL:
8489           case NEW:
8490           case NEW_DOT:
8491           case NO:
8492           case NONEDITIONABLE:
8493           case NOT:
8494           case NULL:
8495           case NULLIF:
8496           case OBJECT:
8497           case OID:
8498           case OPAQUE:
8499           case OPEN:
8500           case OPERATOR:
8501           case ORGANIZATION:
8502           case OTHERS:
8503           case OVERRIDING:
8504           case PACKAGE:
8505           case PARTITION:
8506           case PIPE:
8507           case PRESERVE:
8508           case PRIVATE:
8509           case PROCEDURE:
8510           case RAISE:
8511           case RANGE:
8512           case RAW:
8513           case REAL:
8514           case RECORD:
8515           case REF:
8516           case RELEASE:
8517           case RELIES_ON:
8518           case RENAME:
8519           case RESULT:
8520           case RETURN:
8521           case RETURNING:
8522           case REVERSE:
8523           case ROLLBACK:
8524           case ROW:
8525           case ROWS:
8526           case ROWID:
8527           case ROWNUM:
8528           case SAVE:
8529           case SAVEPOINT:
8530           case SECOND:
8531           case SELECT:
8532           case SELF:
8533           case SET:
8534           case SPACE:
8535           case SQL:
8536           case SQLCODE:
8537           case SQLERRM:
8538           case STATIC:
8539           case SUBTYPE:
8540           case SUBSTITUTABLE:
8541           case SUCCESSFUL:
8542           case SYSDATE:
8543           case SYS_REFCURSOR:
8544           case TEMPORARY:
8545           case TIME:
8546           case TIMESTAMP:
8547           case TIMEZONE_REGION:
8548           case TIMEZONE_ABBR:
8549           case TIMEZONE_MINUTE:
8550           case TIMEZONE_HOUR:
8551           case TRANSACTION:
8552           case TRUE:
8553           case TYPE:
8554           case UNDER:
8555           case USING:
8556           case WHILE:
8557           case YES:
8558           case SHOW:
8559           case A:
8560           case UPDATE:
8561           case DOUBLE:
8562           case DEC:
8563           case PRECISION:
8564           case INT:
8565           case NUMERIC:
8566           case NCHAR:
8567           case NVARCHAR2:
8568           case STRING:
8569           case UROWID:
8570           case VARRAY:
8571           case VARYING:
8572           case BFILE:
8573           case BLOB:
8574           case CLOB:
8575           case NCLOB:
8576           case YEAR:
8577           case LOCAL:
8578           case WITH:
8579           case ZONE:
8580           case CHARACTER:
8581           case AFTER:
8582           case BEFORE:
8583           case OLD:
8584           case PARENT:
8585           case CC_IF:
8586           case CC_ERROR:
8587           case ANALYZE:
8588           case ASSOCIATE:
8589           case AUDIT:
8590           case COMPOUND:
8591           case DATABASE:
8592           case CALL:
8593           case DDL:
8594           case DISASSOCIATE:
8595           case EACH:
8596           case FOLLOWS:
8597           case LOGOFF:
8598           case LOGON:
8599           case NESTED:
8600           case NOAUDIT:
8601           case SCHEMA:
8602           case SERVERERROR:
8603           case SHUTDOWN:
8604           case STARTUP:
8605           case STATEMENT:
8606           case STATISTICS:
8607           case SUSPEND:
8608           case TRUNCATE:
8609           case WRAPPED:
8610           case LIBRARY:
8611           case NAME:
8612           case STRUCT:
8613           case CONTEXT:
8614           case PARAMETERS:
8615           case LENGTH:
8616           case TDO:
8617           case MAXLEN:
8618           case CHARSETID:
8619           case CHARSETFORM:
8620           case ACCEPT:
8621           case ACCESSIBLE:
8622           case COPY:
8623           case DEFINE:
8624           case DISCONNECT:
8625           case HOST:
8626           case PRINT:
8627           case QUIT:
8628           case REMARK:
8629           case UNDEFINE:
8630           case VARIABLE:
8631           case WHENEVER:
8632           case ATTACH:
8633           case CAST:
8634           case TREAT:
8635           case TRIM:
8636           case LEFT:
8637           case RIGHT:
8638           case BOTH:
8639           case EMPTY:
8640           case MULTISET:
8641           case SUBMULTISET:
8642           case LEADING:
8643           case TRAILING:
8644           case CHAR_CS:
8645           case NCHAR_CS:
8646           case DBTIMEZONE:
8647           case SESSIONTIMEZONE:
8648           case AUTHENTICATED:
8649           case LINK:
8650           case SHARED:
8651           case DIRECTORY:
8652           case USER:
8653           case IDENTIFIER:
8654           case UNSIGNED_NUMERIC_LITERAL:
8655           case CHARACTER_LITERAL:
8656           case STRING_LITERAL:
8657           case QUOTED_LITERAL:
8658             ;
8659             break;
8660           default:
8661             jj_la1[115] = jj_gen;
8662             break label_22;
8663           }
8664         }
8665       }
8666       switch (jj_nt.kind) {
8667       case WHEN:
8668         jj_consume_token(WHEN);
8669         jj_consume_token(OTHERS);
8670         jj_consume_token(THEN);
8671         label_23:
8672         while (true) {
8673           Statement();
8674           switch (jj_nt.kind) {
8675           case 5:
8676           case 16:
8677           case 17:
8678           case 21:
8679           case REPLACE:
8680           case DEFINER:
8681           case CURRENT_USER:
8682           case LANGUAGE:
8683           case ADD:
8684           case AGGREGATE:
8685           case ARRAY:
8686           case AT:
8687           case ATTRIBUTE:
8688           case AUTHID:
8689           case BEGIN:
8690           case BODY:
8691           case BULK:
8692           case BYTE:
8693           case CASCADE:
8694           case CASE:
8695           case CLOSE:
8696           case COALESCE:
8697           case COLLECT:
8698           case COLUMN:
8699           case COMMENT:
8700           case COMMIT:
8701           case CONSTRUCTOR:
8702           case CONTINUE:
8703           case CONVERT:
8704           case CURRENT:
8705           case CURSOR:
8706           case DATA:
8707           case DATE:
8708           case DAY:
8709           case DECLARE:
8710           case DELETE:
8711           case DISABLE:
8712           case EDITIONABLE:
8713           case ELEMENT:
8714           case ENABLE:
8715           case ESCAPE:
8716           case EXCEPT:
8717           case EXCEPTIONS:
8718           case EXECUTE:
8719           case EXIT:
8720           case EXTERNAL:
8721           case EXTENDS:
8722           case EXTRACT:
8723           case FALSE:
8724           case FETCH:
8725           case FINAL:
8726           case FOR:
8727           case FORALL:
8728           case FORCE:
8729           case FUNCTION:
8730           case GLOBAL:
8731           case GOTO:
8732           case HASH:
8733           case HEAP:
8734           case HOUR:
8735           case IF:
8736           case IMMEDIATE:
8737           case INDICES:
8738           case INDEXTYPE:
8739           case INDICATOR:
8740           case INSERT:
8741           case INSTANTIABLE:
8742           case INTERVAL:
8743           case INVALIDATE:
8744           case ISOLATION:
8745           case JAVA:
8746           case LEVEL:
8747           case LIMIT:
8748           case LOCK:
8749           case LOOP:
8750           case MAP:
8751           case MAX:
8752           case MEMBER:
8753           case MERGE:
8754           case MIN:
8755           case MINUTE:
8756           case MLSLABEL:
8757           case MODIFY:
8758           case MOD:
8759           case MONTH:
8760           case NATURAL:
8761           case NEW:
8762           case NEW_DOT:
8763           case NO:
8764           case NONEDITIONABLE:
8765           case NOT:
8766           case NULL:
8767           case NULLIF:
8768           case OBJECT:
8769           case OID:
8770           case OPAQUE:
8771           case OPEN:
8772           case OPERATOR:
8773           case ORGANIZATION:
8774           case OTHERS:
8775           case OVERRIDING:
8776           case PACKAGE:
8777           case PARTITION:
8778           case PIPE:
8779           case PRESERVE:
8780           case PRIVATE:
8781           case PROCEDURE:
8782           case RAISE:
8783           case RANGE:
8784           case RAW:
8785           case REAL:
8786           case RECORD:
8787           case REF:
8788           case RELEASE:
8789           case RELIES_ON:
8790           case RENAME:
8791           case RESULT:
8792           case RETURN:
8793           case RETURNING:
8794           case REVERSE:
8795           case ROLLBACK:
8796           case ROW:
8797           case ROWS:
8798           case ROWID:
8799           case ROWNUM:
8800           case SAVE:
8801           case SAVEPOINT:
8802           case SECOND:
8803           case SELECT:
8804           case SELF:
8805           case SET:
8806           case SPACE:
8807           case SQL:
8808           case SQLCODE:
8809           case SQLERRM:
8810           case STATIC:
8811           case SUBTYPE:
8812           case SUBSTITUTABLE:
8813           case SUCCESSFUL:
8814           case SYSDATE:
8815           case SYS_REFCURSOR:
8816           case TEMPORARY:
8817           case TIME:
8818           case TIMESTAMP:
8819           case TIMEZONE_REGION:
8820           case TIMEZONE_ABBR:
8821           case TIMEZONE_MINUTE:
8822           case TIMEZONE_HOUR:
8823           case TRANSACTION:
8824           case TRUE:
8825           case TYPE:
8826           case UNDER:
8827           case USING:
8828           case WHILE:
8829           case YES:
8830           case SHOW:
8831           case A:
8832           case UPDATE:
8833           case DOUBLE:
8834           case DEC:
8835           case PRECISION:
8836           case INT:
8837           case NUMERIC:
8838           case NCHAR:
8839           case NVARCHAR2:
8840           case STRING:
8841           case UROWID:
8842           case VARRAY:
8843           case VARYING:
8844           case BFILE:
8845           case BLOB:
8846           case CLOB:
8847           case NCLOB:
8848           case YEAR:
8849           case LOCAL:
8850           case WITH:
8851           case ZONE:
8852           case CHARACTER:
8853           case AFTER:
8854           case BEFORE:
8855           case OLD:
8856           case PARENT:
8857           case CC_IF:
8858           case CC_ERROR:
8859           case ANALYZE:
8860           case ASSOCIATE:
8861           case AUDIT:
8862           case COMPOUND:
8863           case DATABASE:
8864           case CALL:
8865           case DDL:
8866           case DISASSOCIATE:
8867           case EACH:
8868           case FOLLOWS:
8869           case LOGOFF:
8870           case LOGON:
8871           case NESTED:
8872           case NOAUDIT:
8873           case SCHEMA:
8874           case SERVERERROR:
8875           case SHUTDOWN:
8876           case STARTUP:
8877           case STATEMENT:
8878           case STATISTICS:
8879           case SUSPEND:
8880           case TRUNCATE:
8881           case WRAPPED:
8882           case LIBRARY:
8883           case NAME:
8884           case STRUCT:
8885           case CONTEXT:
8886           case PARAMETERS:
8887           case LENGTH:
8888           case TDO:
8889           case MAXLEN:
8890           case CHARSETID:
8891           case CHARSETFORM:
8892           case ACCEPT:
8893           case ACCESSIBLE:
8894           case COPY:
8895           case DEFINE:
8896           case DISCONNECT:
8897           case HOST:
8898           case PRINT:
8899           case QUIT:
8900           case REMARK:
8901           case UNDEFINE:
8902           case VARIABLE:
8903           case WHENEVER:
8904           case ATTACH:
8905           case CAST:
8906           case TREAT:
8907           case TRIM:
8908           case LEFT:
8909           case RIGHT:
8910           case BOTH:
8911           case EMPTY:
8912           case MULTISET:
8913           case SUBMULTISET:
8914           case LEADING:
8915           case TRAILING:
8916           case CHAR_CS:
8917           case NCHAR_CS:
8918           case DBTIMEZONE:
8919           case SESSIONTIMEZONE:
8920           case AUTHENTICATED:
8921           case LINK:
8922           case SHARED:
8923           case DIRECTORY:
8924           case USER:
8925           case IDENTIFIER:
8926           case UNSIGNED_NUMERIC_LITERAL:
8927           case CHARACTER_LITERAL:
8928           case STRING_LITERAL:
8929           case QUOTED_LITERAL:
8930             ;
8931             break;
8932           default:
8933             jj_la1[116] = jj_gen;
8934             break label_23;
8935           }
8936         }
8937         break;
8938       default:
8939         jj_la1[117] = jj_gen;
8940         ;
8941       }
8942         jjtree.closeNodeScope(jjtn000, true);
8943         jjtc000 = false;
8944         {if (true) return jjtn000 ;}
8945     } catch (Throwable jjte000) {
8946         if (jjtc000) {
8947           jjtree.clearNodeScope(jjtn000);
8948           jjtc000 = false;
8949         } else {
8950           jjtree.popNode();
8951         }
8952         if (jjte000 instanceof RuntimeException) {
8953           {if (true) throw (RuntimeException)jjte000;}
8954         }
8955         if (jjte000 instanceof ParseException) {
8956           {if (true) throw (ParseException)jjte000;}
8957         }
8958         {if (true) throw (Error)jjte000;}
8959     } finally {
8960         if (jjtc000) {
8961           jjtree.closeNodeScope(jjtn000, true);
8962         }
8963     }
8964     throw new Error("Missing return statement in function");
8965   }
8966 
8967   final public void Skip2NextTerminator(String initiator,String terminator) throws ParseException {
8968  /*@bgen(jjtree) Skip2NextTerminator */
8969   ASTSkip2NextTerminator jjtn000 = new ASTSkip2NextTerminator(this, JJTSKIP2NEXTTERMINATOR);
8970   boolean jjtc000 = true;
8971   jjtree.openNodeScope(jjtn000);Token t = getToken(1);
8972   int count = (initiator == null) ? 0 : 1;
8973   if(t.image.equals(initiator)) count++;
8974   while (count > 0 || !t.image.equals(terminator))
8975   {
8976     t = getNextToken();
8977     t = getToken(1);
8978           if(t.image.equals(initiator)) count++;
8979           if(t.image.equals(terminator)) count--;
8980   }
8981     try {
8982           jjtree.closeNodeScope(jjtn000, true);
8983           jjtc000 = false;
8984           {if (true) return;}
8985     } finally {
8986           if (jjtc000) {
8987             jjtree.closeNodeScope(jjtn000, true);
8988           }
8989     }
8990   }
8991 
8992 /*
8993  Read Tokens up to but not including the target String. 
8994 */
8995   final public void Skip2NextOccurrence(String target) throws ParseException {
8996  /*@bgen(jjtree) Skip2NextOccurrence */
8997   ASTSkip2NextOccurrence jjtn000 = new ASTSkip2NextOccurrence(this, JJTSKIP2NEXTOCCURRENCE);
8998   boolean jjtc000 = true;
8999   jjtree.openNodeScope(jjtn000);Token nextToken = getToken(1);
9000   while (!nextToken.image.equals(target)
9001          && (null == nextToken.specialToken || !nextToken.specialToken.image.equals(target) ) //In case the target is a Special Token
9002          && nextToken.kind!=EOF //SRT 20110521 - Prevent endless loop when target does not exist in the input stream
9003         )
9004   {
9005     nextToken = getNextToken();
9006     nextToken = getToken(1);
9007   }
9008     try {
9009           jjtree.closeNodeScope(jjtn000, true);
9010           jjtc000 = false;
9011           {if (true) return;}
9012     } finally {
9013           if (jjtc000) {
9014             jjtree.closeNodeScope(jjtn000, true);
9015           }
9016     }
9017   }
9018 
9019 /*
9020  Read Tokens up to and including the target String. 
9021 */
9022   final public void SkipPastNextOccurrence(String target) throws ParseException {
9023  /*@bgen(jjtree) SkipPastNextOccurrence */
9024   ASTSkipPastNextOccurrence jjtn000 = new ASTSkipPastNextOccurrence(this, JJTSKIPPASTNEXTOCCURRENCE);
9025   boolean jjtc000 = true;
9026   jjtree.openNodeScope(jjtn000);Token t = null;
9027   Skip2NextOccurrence(target) ;
9028   t = getNextToken();
9029     try {
9030           jjtree.closeNodeScope(jjtn000, true);
9031           jjtc000 = false;
9032           {if (true) return;}
9033     } finally {
9034           if (jjtc000) {
9035             jjtree.closeNodeScope(jjtn000, true);
9036           }
9037     }
9038   }
9039 
9040 /*
9041  Read Tokens up to but not including the target Token.kind. 
9042 */
9043   final public void Skip2NextTokenOccurrence(int target) throws ParseException {
9044  /*@bgen(jjtree) Skip2NextTokenOccurrence */
9045   ASTSkip2NextTokenOccurrence jjtn000 = new ASTSkip2NextTokenOccurrence(this, JJTSKIP2NEXTTOKENOCCURRENCE);
9046   boolean jjtc000 = true;
9047   jjtree.openNodeScope(jjtn000);Token nextToken = getToken(1);
9048   Token specToken = null ;
9049   while (nextToken.kind!=target
9050          && (null == nextToken.specialToken || nextToken.specialToken.kind!=target ) //In case the target is a Special Token
9051          && nextToken.kind!=EOF //SRT 20110521 - Prevent endless loop when target does not exist in the input stream
9052         )
9053   {
9054     /*
9055 	Check if the target appears as a SpecialToken 
9056 
9057 
9058 	nextToken.specialToken points to the _LAST_ of any SpecialTokens before the current normal Token.
9059 
9060 	It is the head of a doubly-linked list:
9061 
9062 	The ${specialToken}.specialToken field POINTS BACKWARDS TOWARDS the FIRST occurring SpecialToken
9063 	The ${specialToken}.next field POINTS FORWARDS to to the LAST occurring SpecialToken
9064 
9065 	This means that if the program is interested in a specific SpecialToken, it must examine the linked list for every Token which has nexToken.specialToken != null.
9066     
9067     */
9068     specToken = nextToken.specialToken;
9069     if (null!= specToken)
9070     {
9071         //Walk backwards through the list looking for this Token as a Special Token 
9072         while (specToken != null && specToken.kind != target)
9073         {
9074                 specToken = specToken.specialToken;
9075         }
9076 
9077         //We have found the target as a SpecialToken - break out of normal Token search
9078         if (null != specToken && specToken.kind == target)
9079         {
9080                 break;
9081         }
9082     }
9083 
9084     nextToken = getNextToken();
9085     nextToken = getToken(1);
9086   }
9087     try {
9088           jjtree.closeNodeScope(jjtn000, true);
9089           jjtc000 = false;
9090           {if (true) return;}
9091     } finally {
9092           if (jjtc000) {
9093             jjtree.closeNodeScope(jjtn000, true);
9094           }
9095     }
9096   }
9097 
9098 /*
9099  Read Tokens up to and including the target Token.kind. 
9100 */
9101   final public void SkipPastNextTokenOccurrence(int target) throws ParseException {
9102  /*@bgen(jjtree) SkipPastNextTokenOccurrence */
9103   ASTSkipPastNextTokenOccurrence jjtn000 = new ASTSkipPastNextTokenOccurrence(this, JJTSKIPPASTNEXTTOKENOCCURRENCE);
9104   boolean jjtc000 = true;
9105   jjtree.openNodeScope(jjtn000);Token t = null;
9106   Skip2NextTokenOccurrence(target) ;
9107   t = getNextToken();
9108     try {
9109           jjtree.closeNodeScope(jjtn000, true);
9110           jjtc000 = false;
9111           {if (true) return;}
9112     } finally {
9113           if (jjtc000) {
9114             jjtree.closeNodeScope(jjtn000, true);
9115           }
9116     }
9117   }
9118 
9119 /*
9120  Read Tokens up to but not including the target String. 
9121 */
9122   final public ASTRead2NextOccurrence Read2NextOccurrence(String target) throws ParseException {
9123  /*@bgen(jjtree) Read2NextOccurrence */
9124   ASTRead2NextOccurrence jjtn000 = new ASTRead2NextOccurrence(this, JJTREAD2NEXTOCCURRENCE);
9125   boolean jjtc000 = true;
9126   jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
9127   Token nextToken = getToken(1);
9128   while (!nextToken.image.equals(target)
9129          && nextToken.kind!=EOF
9130         )
9131   {
9132     nextToken = getNextToken();
9133     sb.append(nextToken.image);
9134     nextToken = getToken(1);
9135   }
9136     try {
9137           jjtree.closeNodeScope(jjtn000, true);
9138           jjtc000 = false;
9139           jjtn000.setImage(sb.toString()) ;  jjtn000.value = sb.toString(); {if (true) return jjtn000 ;}
9140     } finally {
9141           if (jjtc000) {
9142             jjtree.closeNodeScope(jjtn000, true);
9143           }
9144     }
9145     throw new Error("Missing return statement in function");
9146   }
9147 
9148 /*
9149  Read Tokens up to and including the target String. 
9150 */
9151   final public ASTReadPastNextOccurrence ReadPastNextOccurrence(String target) throws ParseException {
9152  /*@bgen(jjtree) ReadPastNextOccurrence */
9153   ASTReadPastNextOccurrence jjtn000 = new ASTReadPastNextOccurrence(this, JJTREADPASTNEXTOCCURRENCE);
9154   boolean jjtc000 = true;
9155   jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
9156   Token t = null;
9157   sb.append(Read2NextOccurrence(target)) ;
9158   t = getNextToken(); // Chomp this one 
9159   sb.append(t.image);
9160     try {
9161           jjtree.closeNodeScope(jjtn000, true);
9162           jjtc000 = false;
9163           jjtn000.setImage(sb.toString()) ;  jjtn000.value = sb.toString(); {if (true) return jjtn000 ;}
9164     } finally {
9165           if (jjtc000) {
9166             jjtree.closeNodeScope(jjtn000, true);
9167           }
9168     }
9169     throw new Error("Missing return statement in function");
9170   }
9171 
9172 /**
9173  * 2006-05-24 - Matthias Hendler - added MERGE
9174  */
9175   final public ASTSqlStatement SqlStatement(String initiator, String terminator) throws ParseException {
9176  /*@bgen(jjtree) SqlStatement */
9177   ASTSqlStatement jjtn000 = new ASTSqlStatement(this, JJTSQLSTATEMENT);
9178   boolean jjtc000 = true;
9179   jjtree.openNodeScope(jjtn000);
9180     try {
9181       switch (jj_nt.kind) {
9182       case SELECT:
9183         jj_consume_token(SELECT);
9184         break;
9185       case UPDATE:
9186         jj_consume_token(UPDATE);
9187         break;
9188       case INSERT:
9189         jj_consume_token(INSERT);
9190         break;
9191       case DELETE:
9192         jj_consume_token(DELETE);
9193         break;
9194       case COMMIT:
9195         jj_consume_token(COMMIT);
9196         break;
9197       case ROLLBACK:
9198         jj_consume_token(ROLLBACK);
9199         break;
9200       case SAVEPOINT:
9201         jj_consume_token(SAVEPOINT);
9202         break;
9203       case EXECUTE:
9204         jj_consume_token(EXECUTE);
9205         break;
9206       case SET:
9207         jj_consume_token(SET);
9208         jj_consume_token(TRANSACTION);
9209         break;
9210       case LOCK:
9211         jj_consume_token(LOCK);
9212         jj_consume_token(TABLE);
9213         break;
9214       case MERGE:
9215         jj_consume_token(MERGE);
9216         break;
9217       case WITH:
9218         jj_consume_token(WITH);
9219         break;
9220       default:
9221         jj_la1[118] = jj_gen;
9222         jj_consume_token(-1);
9223         throw new ParseException();
9224       }
9225       Skip2NextTerminator(initiator,terminator);
9226           jjtree.closeNodeScope(jjtn000, true);
9227           jjtc000 = false;
9228           {if (true) return jjtn000 ;}
9229     } catch (Throwable jjte000) {
9230           if (jjtc000) {
9231             jjtree.clearNodeScope(jjtn000);
9232             jjtc000 = false;
9233           } else {
9234             jjtree.popNode();
9235           }
9236           if (jjte000 instanceof RuntimeException) {
9237             {if (true) throw (RuntimeException)jjte000;}
9238           }
9239           if (jjte000 instanceof ParseException) {
9240             {if (true) throw (ParseException)jjte000;}
9241           }
9242           {if (true) throw (Error)jjte000;}
9243     } finally {
9244           if (jjtc000) {
9245             jjtree.closeNodeScope(jjtn000, true);
9246           }
9247     }
9248     throw new Error("Missing return statement in function");
9249   }
9250 
9251 /**
9252  * 2011-05-15 - SRT - Added to cope with wrapped objects
9253   A wrapped function looks like this (always terminated by one or more equals signs "="):-
9254   "  CREATE OR REPLACE FUNCTION "TESTUSER"."GET_DATE_STRING"
9255 / ** Return SYSDATE formatted using the provided template.
9256  *
9257  *
9258  *  @param p_date_format normal TO_CHARE/TO_DATE date template
9259  *  @return formatted datestring
9260  *  @see http://www.oracle-base.com/articles/10g/WrapAndDBMS_DDL_10gR2.php#dbms_ddl
9261  * /
9262 wrapped
9263 a000000
9264 369
9265 abcd
9266 abcd
9267 abcd
9268 abcd
9269 abcd
9270 abcd
9271 abcd
9272 abcd
9273 abcd
9274 abcd
9275 abcd
9276 abcd
9277 abcd
9278 abcd
9279 abcd
9280 8
9281 89 b6
9282 /SBrhM8+1iUO4QAih+qD2SK8kSowg8eZgcfLCNL+XlquYvSuoVah8JbRPpdHDLHn479SdFLw
9283 v04omzJ0zOfHdMAzuHQlw+fAsr2ym9YI8I521pRTbnFVAHOOUw4JqPkIyj7wj4VwyL17nhYb
9284 3qPVuL6SvhZTmEBnRtaErHpzaDuIpqZ0G4s=
9285   "
9286  */
9287   final public void WrappedObject() throws ParseException {
9288  /*@bgen(jjtree) WrappedObject */
9289   ASTWrappedObject jjtn000 = new ASTWrappedObject(this, JJTWRAPPEDOBJECT);
9290   boolean jjtc000 = true;
9291   jjtree.openNodeScope(jjtn000);
9292     try {
9293       jj_consume_token(WRAPPED);
9294           jjtree.closeNodeScope(jjtn000, true);
9295           jjtc000 = false;
9296            Token nextToken;
9297 
9298                 nextToken = getToken(1); //ReadAhead
9299                 while (
9300                      null != nextToken && nextToken.kind!=EOF
9301                      )
9302                 {
9303                         nextToken = getNextToken();
9304 
9305                         //Execute manual readahead 
9306                         nextToken = getToken(1); //ReadAhead 1 Token 
9307                 }
9308                 {if (true) return;}
9309     } finally {
9310           if (jjtc000) {
9311             jjtree.closeNodeScope(jjtn000, true);
9312           }
9313     }
9314   }
9315 
9316 // ============================================================================
9317 // S T A T E M E N T S
9318 // ============================================================================
9319 
9320 /**
9321  * 2006-05-24 - Matthias Hendler - added MERGE, EXECUTE choice and LOOKAHEAD at <LOOP>
9322  */
9323   final public ASTUnlabelledStatement UnlabelledStatement() throws ParseException {
9324  /*@bgen(jjtree) UnlabelledStatement */
9325   ASTUnlabelledStatement jjtn000 = new ASTUnlabelledStatement(this, JJTUNLABELLEDSTATEMENT);
9326   boolean jjtc000 = true;
9327   jjtree.openNodeScope(jjtn000);
9328     try {
9329       if (jj_2_42(2147483647)) {
9330         SqlStatement(null,";");
9331         switch (jj_nt.kind) {
9332         case 4:
9333           jj_consume_token(4);
9334           break;
9335         default:
9336           jj_la1[119] = jj_gen;
9337           ;
9338         }
9339       } else if (jj_2_43(3)) {
9340         ContinueStatement();
9341         jj_consume_token(4);
9342       } else {
9343         switch (jj_nt.kind) {
9344         case CASE:
9345           CaseStatement();
9346           jj_consume_token(4);
9347           break;
9348         case IF:
9349           IfStatement();
9350           jj_consume_token(4);
9351           break;
9352         case FOR:
9353           ForStatement();
9354           jj_consume_token(4);
9355           break;
9356         case FORALL:
9357           ForAllStatement();
9358           jj_consume_token(4);
9359           break;
9360         case LOOP:
9361           LoopStatement();
9362           jj_consume_token(4);
9363           break;
9364         case WHILE:
9365           WhileStatement();
9366           jj_consume_token(4);
9367           break;
9368         case GOTO:
9369           GotoStatement();
9370           jj_consume_token(4);
9371           break;
9372         case RETURN:
9373           ReturnStatement();
9374           jj_consume_token(4);
9375           break;
9376         case EXIT:
9377           ExitStatement();
9378           jj_consume_token(4);
9379           break;
9380         case RAISE:
9381           RaiseStatement();
9382           jj_consume_token(4);
9383           break;
9384         case CLOSE:
9385           CloseStatement();
9386           jj_consume_token(4);
9387           break;
9388         case OPEN:
9389           OpenStatement();
9390           jj_consume_token(4);
9391           break;
9392         case FETCH:
9393           FetchStatement();
9394           jj_consume_token(4);
9395           break;
9396         case BEGIN:
9397         case DECLARE:
9398           Block();
9399           jj_consume_token(4);
9400           break;
9401         case EXECUTE:
9402           EmbeddedSqlStatement();
9403           jj_consume_token(4);
9404           break;
9405         case PIPE:
9406           PipelineStatement();
9407           jj_consume_token(4);
9408           break;
9409         case CC_IF:
9410         case CC_ERROR:
9411           ConditionalCompilationStatement();
9412           break;
9413         case 5:
9414         case 16:
9415         case 17:
9416         case REPLACE:
9417         case DEFINER:
9418         case CURRENT_USER:
9419         case LANGUAGE:
9420         case ADD:
9421         case AGGREGATE:
9422         case ARRAY:
9423         case AT:
9424         case ATTRIBUTE:
9425         case AUTHID:
9426         case BODY:
9427         case BULK:
9428         case BYTE:
9429         case CASCADE:
9430         case COALESCE:
9431         case COLLECT:
9432         case COLUMN:
9433         case COMMENT:
9434         case COMMIT:
9435         case CONSTRUCTOR:
9436         case CONTINUE:
9437         case CONVERT:
9438         case CURRENT:
9439         case CURSOR:
9440         case DATA:
9441         case DATE:
9442         case DAY:
9443         case DISABLE:
9444         case EDITIONABLE:
9445         case ELEMENT:
9446         case ENABLE:
9447         case ESCAPE:
9448         case EXCEPT:
9449         case EXCEPTIONS:
9450         case EXTERNAL:
9451         case EXTENDS:
9452         case EXTRACT:
9453         case FALSE:
9454         case FINAL:
9455         case FORCE:
9456         case FUNCTION:
9457         case GLOBAL:
9458         case HASH:
9459         case HEAP:
9460         case HOUR:
9461         case IMMEDIATE:
9462         case INDICES:
9463         case INDEXTYPE:
9464         case INDICATOR:
9465         case INSTANTIABLE:
9466         case INTERVAL:
9467         case INVALIDATE:
9468         case ISOLATION:
9469         case JAVA:
9470         case LEVEL:
9471         case LIMIT:
9472         case MAP:
9473         case MAX:
9474         case MEMBER:
9475         case MERGE:
9476         case MIN:
9477         case MINUTE:
9478         case MLSLABEL:
9479         case MODIFY:
9480         case MOD:
9481         case MONTH:
9482         case NATURAL:
9483         case NEW:
9484         case NEW_DOT:
9485         case NO:
9486         case NONEDITIONABLE:
9487         case NOT:
9488         case NULL:
9489         case NULLIF:
9490         case OBJECT:
9491         case OID:
9492         case OPAQUE:
9493         case OPERATOR:
9494         case ORGANIZATION:
9495         case OTHERS:
9496         case OVERRIDING:
9497         case PACKAGE:
9498         case PARTITION:
9499         case PRESERVE:
9500         case PRIVATE:
9501         case PROCEDURE:
9502         case RANGE:
9503         case RAW:
9504         case REAL:
9505         case RECORD:
9506         case REF:
9507         case RELEASE:
9508         case RELIES_ON:
9509         case RENAME:
9510         case RESULT:
9511         case RETURNING:
9512         case REVERSE:
9513         case ROLLBACK:
9514         case ROW:
9515         case ROWS:
9516         case ROWID:
9517         case ROWNUM:
9518         case SAVE:
9519         case SAVEPOINT:
9520         case SECOND:
9521         case SELECT:
9522         case SELF:
9523         case SET:
9524         case SPACE:
9525         case SQL:
9526         case SQLCODE:
9527         case SQLERRM:
9528         case STATIC:
9529         case SUBTYPE:
9530         case SUBSTITUTABLE:
9531         case SUCCESSFUL:
9532         case SYSDATE:
9533         case SYS_REFCURSOR:
9534         case TEMPORARY:
9535         case TIME:
9536         case TIMESTAMP:
9537         case TIMEZONE_REGION:
9538         case TIMEZONE_ABBR:
9539         case TIMEZONE_MINUTE:
9540         case TIMEZONE_HOUR:
9541         case TRANSACTION:
9542         case TRUE:
9543         case TYPE:
9544         case UNDER:
9545         case USING:
9546         case YES:
9547         case SHOW:
9548         case A:
9549         case DOUBLE:
9550         case DEC:
9551         case PRECISION:
9552         case INT:
9553         case NUMERIC:
9554         case NCHAR:
9555         case NVARCHAR2:
9556         case STRING:
9557         case UROWID:
9558         case VARRAY:
9559         case VARYING:
9560         case BFILE:
9561         case BLOB:
9562         case CLOB:
9563         case NCLOB:
9564         case YEAR:
9565         case LOCAL:
9566         case WITH:
9567         case ZONE:
9568         case CHARACTER:
9569         case AFTER:
9570         case BEFORE:
9571         case OLD:
9572         case PARENT:
9573         case ANALYZE:
9574         case ASSOCIATE:
9575         case AUDIT:
9576         case COMPOUND:
9577         case DATABASE:
9578         case CALL:
9579         case DDL:
9580         case DISASSOCIATE:
9581         case EACH:
9582         case FOLLOWS:
9583         case LOGOFF:
9584         case LOGON:
9585         case NESTED:
9586         case NOAUDIT:
9587         case SCHEMA:
9588         case SERVERERROR:
9589         case SHUTDOWN:
9590         case STARTUP:
9591         case STATEMENT:
9592         case STATISTICS:
9593         case SUSPEND:
9594         case TRUNCATE:
9595         case WRAPPED:
9596         case LIBRARY:
9597         case NAME:
9598         case STRUCT:
9599         case CONTEXT:
9600         case PARAMETERS:
9601         case LENGTH:
9602         case TDO:
9603         case MAXLEN:
9604         case CHARSETID:
9605         case CHARSETFORM:
9606         case ACCEPT:
9607         case ACCESSIBLE:
9608         case COPY:
9609         case DEFINE:
9610         case DISCONNECT:
9611         case HOST:
9612         case PRINT:
9613         case QUIT:
9614         case REMARK:
9615         case UNDEFINE:
9616         case VARIABLE:
9617         case WHENEVER:
9618         case ATTACH:
9619         case CAST:
9620         case TREAT:
9621         case TRIM:
9622         case LEFT:
9623         case RIGHT:
9624         case BOTH:
9625         case EMPTY:
9626         case MULTISET:
9627         case SUBMULTISET:
9628         case LEADING:
9629         case TRAILING:
9630         case CHAR_CS:
9631         case NCHAR_CS:
9632         case DBTIMEZONE:
9633         case SESSIONTIMEZONE:
9634         case AUTHENTICATED:
9635         case LINK:
9636         case SHARED:
9637         case DIRECTORY:
9638         case USER:
9639         case IDENTIFIER:
9640         case UNSIGNED_NUMERIC_LITERAL:
9641         case CHARACTER_LITERAL:
9642         case STRING_LITERAL:
9643         case QUOTED_LITERAL:
9644           Expression();
9645           jj_consume_token(4);
9646           break;
9647         default:
9648           jj_la1[120] = jj_gen;
9649           jj_consume_token(-1);
9650           throw new ParseException();
9651         }
9652       }
9653         jjtree.closeNodeScope(jjtn000, true);
9654         jjtc000 = false;
9655         {if (true) return jjtn000 ;}
9656     } catch (Throwable jjte000) {
9657          if (jjtc000) {
9658            jjtree.clearNodeScope(jjtn000);
9659            jjtc000 = false;
9660          } else {
9661            jjtree.popNode();
9662          }
9663          if (jjte000 instanceof RuntimeException) {
9664            {if (true) throw (RuntimeException)jjte000;}
9665          }
9666          if (jjte000 instanceof ParseException) {
9667            {if (true) throw (ParseException)jjte000;}
9668          }
9669          {if (true) throw (Error)jjte000;}
9670     } finally {
9671          if (jjtc000) {
9672            jjtree.closeNodeScope(jjtn000, true);
9673          }
9674     }
9675     throw new Error("Missing return statement in function");
9676   }
9677 
9678   final public ASTStatement Statement() throws ParseException {
9679  /*@bgen(jjtree) Statement */
9680   ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT);
9681   boolean jjtc000 = true;
9682   jjtree.openNodeScope(jjtn000);
9683     try {
9684       switch (jj_nt.kind) {
9685       case 21:
9686         LabelledStatement();
9687         break;
9688       case 5:
9689       case 16:
9690       case 17:
9691       case REPLACE:
9692       case DEFINER:
9693       case CURRENT_USER:
9694       case LANGUAGE:
9695       case ADD:
9696       case AGGREGATE:
9697       case ARRAY:
9698       case AT:
9699       case ATTRIBUTE:
9700       case AUTHID:
9701       case BEGIN:
9702       case BODY:
9703       case BULK:
9704       case BYTE:
9705       case CASCADE:
9706       case CASE:
9707       case CLOSE:
9708       case COALESCE:
9709       case COLLECT:
9710       case COLUMN:
9711       case COMMENT:
9712       case COMMIT:
9713       case CONSTRUCTOR:
9714       case CONTINUE:
9715       case CONVERT:
9716       case CURRENT:
9717       case CURSOR:
9718       case DATA:
9719       case DATE:
9720       case DAY:
9721       case DECLARE:
9722       case DELETE:
9723       case DISABLE:
9724       case EDITIONABLE:
9725       case ELEMENT:
9726       case ENABLE:
9727       case ESCAPE:
9728       case EXCEPT:
9729       case EXCEPTIONS:
9730       case EXECUTE:
9731       case EXIT:
9732       case EXTERNAL:
9733       case EXTENDS:
9734       case EXTRACT:
9735       case FALSE:
9736       case FETCH:
9737       case FINAL:
9738       case FOR:
9739       case FORALL:
9740       case FORCE:
9741       case FUNCTION:
9742       case GLOBAL:
9743       case GOTO:
9744       case HASH:
9745       case HEAP:
9746       case HOUR:
9747       case IF:
9748       case IMMEDIATE:
9749       case INDICES:
9750       case INDEXTYPE:
9751       case INDICATOR:
9752       case INSERT:
9753       case INSTANTIABLE:
9754       case INTERVAL:
9755       case INVALIDATE:
9756       case ISOLATION:
9757       case JAVA:
9758       case LEVEL:
9759       case LIMIT:
9760       case LOCK:
9761       case LOOP:
9762       case MAP:
9763       case MAX:
9764       case MEMBER:
9765       case MERGE:
9766       case MIN:
9767       case MINUTE:
9768       case MLSLABEL:
9769       case MODIFY:
9770       case MOD:
9771       case MONTH:
9772       case NATURAL:
9773       case NEW:
9774       case NEW_DOT:
9775       case NO:
9776       case NONEDITIONABLE:
9777       case NOT:
9778       case NULL:
9779       case NULLIF:
9780       case OBJECT:
9781       case OID:
9782       case OPAQUE:
9783       case OPEN:
9784       case OPERATOR:
9785       case ORGANIZATION:
9786       case OTHERS:
9787       case OVERRIDING:
9788       case PACKAGE:
9789       case PARTITION:
9790       case PIPE:
9791       case PRESERVE:
9792       case PRIVATE:
9793       case PROCEDURE:
9794       case RAISE:
9795       case RANGE:
9796       case RAW:
9797       case REAL:
9798       case RECORD:
9799       case REF:
9800       case RELEASE:
9801       case RELIES_ON:
9802       case RENAME:
9803       case RESULT:
9804       case RETURN:
9805       case RETURNING:
9806       case REVERSE:
9807       case ROLLBACK:
9808       case ROW:
9809       case ROWS:
9810       case ROWID:
9811       case ROWNUM:
9812       case SAVE:
9813       case SAVEPOINT:
9814       case SECOND:
9815       case SELECT:
9816       case SELF:
9817       case SET:
9818       case SPACE:
9819       case SQL:
9820       case SQLCODE:
9821       case SQLERRM:
9822       case STATIC:
9823       case SUBTYPE:
9824       case SUBSTITUTABLE:
9825       case SUCCESSFUL:
9826       case SYSDATE:
9827       case SYS_REFCURSOR:
9828       case TEMPORARY:
9829       case TIME:
9830       case TIMESTAMP:
9831       case TIMEZONE_REGION:
9832       case TIMEZONE_ABBR:
9833       case TIMEZONE_MINUTE:
9834       case TIMEZONE_HOUR:
9835       case TRANSACTION:
9836       case TRUE:
9837       case TYPE:
9838       case UNDER:
9839       case USING:
9840       case WHILE:
9841       case YES:
9842       case SHOW:
9843       case A:
9844       case UPDATE:
9845       case DOUBLE:
9846       case DEC:
9847       case PRECISION:
9848       case INT:
9849       case NUMERIC:
9850       case NCHAR:
9851       case NVARCHAR2:
9852       case STRING:
9853       case UROWID:
9854       case VARRAY:
9855       case VARYING:
9856       case BFILE:
9857       case BLOB:
9858       case CLOB:
9859       case NCLOB:
9860       case YEAR:
9861       case LOCAL:
9862       case WITH:
9863       case ZONE:
9864       case CHARACTER:
9865       case AFTER:
9866       case BEFORE:
9867       case OLD:
9868       case PARENT:
9869       case CC_IF:
9870       case CC_ERROR:
9871       case ANALYZE:
9872       case ASSOCIATE:
9873       case AUDIT:
9874       case COMPOUND:
9875       case DATABASE:
9876       case CALL:
9877       case DDL:
9878       case DISASSOCIATE:
9879       case EACH:
9880       case FOLLOWS:
9881       case LOGOFF:
9882       case LOGON:
9883       case NESTED:
9884       case NOAUDIT:
9885       case SCHEMA:
9886       case SERVERERROR:
9887       case SHUTDOWN:
9888       case STARTUP:
9889       case STATEMENT:
9890       case STATISTICS:
9891       case SUSPEND:
9892       case TRUNCATE:
9893       case WRAPPED:
9894       case LIBRARY:
9895       case NAME:
9896       case STRUCT:
9897       case CONTEXT:
9898       case PARAMETERS:
9899       case LENGTH:
9900       case TDO:
9901       case MAXLEN:
9902       case CHARSETID:
9903       case CHARSETFORM:
9904       case ACCEPT:
9905       case ACCESSIBLE:
9906       case COPY:
9907       case DEFINE:
9908       case DISCONNECT:
9909       case HOST:
9910       case PRINT:
9911       case QUIT:
9912       case REMARK:
9913       case UNDEFINE:
9914       case VARIABLE:
9915       case WHENEVER:
9916       case ATTACH:
9917       case CAST:
9918       case TREAT:
9919       case TRIM:
9920       case LEFT:
9921       case RIGHT:
9922       case BOTH:
9923       case EMPTY:
9924       case MULTISET:
9925       case SUBMULTISET:
9926       case LEADING:
9927       case TRAILING:
9928       case CHAR_CS:
9929       case NCHAR_CS:
9930       case DBTIMEZONE:
9931       case SESSIONTIMEZONE:
9932       case AUTHENTICATED:
9933       case LINK:
9934       case SHARED:
9935       case DIRECTORY:
9936       case USER:
9937       case IDENTIFIER:
9938       case UNSIGNED_NUMERIC_LITERAL:
9939       case CHARACTER_LITERAL:
9940       case STRING_LITERAL:
9941       case QUOTED_LITERAL:
9942         UnlabelledStatement();
9943         break;
9944       default:
9945         jj_la1[121] = jj_gen;
9946         jj_consume_token(-1);
9947         throw new ParseException();
9948       }
9949         jjtree.closeNodeScope(jjtn000, true);
9950         jjtc000 = false;
9951         {if (true) return jjtn000 ;}
9952     } catch (Throwable jjte000) {
9953         if (jjtc000) {
9954           jjtree.clearNodeScope(jjtn000);
9955           jjtc000 = false;
9956         } else {
9957           jjtree.popNode();
9958         }
9959         if (jjte000 instanceof RuntimeException) {
9960           {if (true) throw (RuntimeException)jjte000;}
9961         }
9962         if (jjte000 instanceof ParseException) {
9963           {if (true) throw (ParseException)jjte000;}
9964         }
9965         {if (true) throw (Error)jjte000;}
9966     } finally {
9967         if (jjtc000) {
9968           jjtree.closeNodeScope(jjtn000, true);
9969         }
9970     }
9971     throw new Error("Missing return statement in function");
9972   }
9973 
9974 /*
9975 LabelledStatement created solely to conform with PMD Java AST (for PMD DataFlow Analysis - DFA)
9976 N.B. equivalent Java AST* class is ASTLabeledStatement (single "l" rather than double "ll")
9977 */
9978   final public ASTLabelledStatement LabelledStatement() throws ParseException {
9979  /*@bgen(jjtree) LabelledStatement */
9980 ASTLabelledStatement jjtn000 = new ASTLabelledStatement(this, JJTLABELLEDSTATEMENT);
9981 boolean jjtc000 = true;
9982 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
9983     try {
9984       label_24:
9985       while (true) {
9986         simpleNode = Label();
9987         switch (jj_nt.kind) {
9988         case 21:
9989           ;
9990           break;
9991         default:
9992           jj_la1[122] = jj_gen;
9993           break label_24;
9994         }
9995       }
9996       UnlabelledStatement();
9997         jjtree.closeNodeScope(jjtn000, true);
9998         jjtc000 = false;
9999         jjtn000.setImage( simpleNode.getImage() ) ;
10000        {if (true) return jjtn000 ;}
10001     } catch (Throwable jjte000) {
10002         if (jjtc000) {
10003           jjtree.clearNodeScope(jjtn000);
10004           jjtc000 = false;
10005         } else {
10006           jjtree.popNode();
10007         }
10008         if (jjte000 instanceof RuntimeException) {
10009           {if (true) throw (RuntimeException)jjte000;}
10010         }
10011         if (jjte000 instanceof ParseException) {
10012           {if (true) throw (ParseException)jjte000;}
10013         }
10014         {if (true) throw (Error)jjte000;}
10015     } finally {
10016         if (jjtc000) {
10017           jjtree.closeNodeScope(jjtn000, true);
10018         }
10019     }
10020     throw new Error("Missing return statement in function");
10021   }
10022 
10023   final public ASTCaseStatement CaseStatement() throws ParseException {
10024  /*@bgen(jjtree) CaseStatement */
10025   ASTCaseStatement jjtn000 = new ASTCaseStatement(this, JJTCASESTATEMENT);
10026   boolean jjtc000 = true;
10027   jjtree.openNodeScope(jjtn000);
10028     try {
10029       jj_consume_token(CASE);
10030       switch (jj_nt.kind) {
10031       case 5:
10032       case 16:
10033       case 17:
10034       case REPLACE:
10035       case DEFINER:
10036       case CURRENT_USER:
10037       case LANGUAGE:
10038       case ADD:
10039       case AGGREGATE:
10040       case ARRAY:
10041       case AT:
10042       case ATTRIBUTE:
10043       case AUTHID:
10044       case BODY:
10045       case BULK:
10046       case BYTE:
10047       case CASCADE:
10048       case CASE:
10049       case CLOSE:
10050       case COALESCE:
10051       case COLLECT:
10052       case COLUMN:
10053       case COMMENT:
10054       case COMMIT:
10055       case CONSTRUCTOR:
10056       case CONTINUE:
10057       case CONVERT:
10058       case CURRENT:
10059       case CURSOR:
10060       case DATA:
10061       case DATE:
10062       case DAY:
10063       case DISABLE:
10064       case EDITIONABLE:
10065       case ELEMENT:
10066       case ENABLE:
10067       case ESCAPE:
10068       case EXCEPT:
10069       case EXCEPTIONS:
10070       case EXIT:
10071       case EXTERNAL:
10072       case EXTENDS:
10073       case EXTRACT:
10074       case FALSE:
10075       case FINAL:
10076       case FORCE:
10077       case FUNCTION:
10078       case GLOBAL:
10079       case HASH:
10080       case HEAP:
10081       case HOUR:
10082       case IMMEDIATE:
10083       case INDICES:
10084       case INDEXTYPE:
10085       case INDICATOR:
10086       case INSTANTIABLE:
10087       case INTERVAL:
10088       case INVALIDATE:
10089       case ISOLATION:
10090       case JAVA:
10091       case LEVEL:
10092       case LIMIT:
10093       case LOOP:
10094       case MAP:
10095       case MAX:
10096       case MEMBER:
10097       case MERGE:
10098       case MIN:
10099       case MINUTE:
10100       case MLSLABEL:
10101       case MODIFY:
10102       case MOD:
10103       case MONTH:
10104       case NATURAL:
10105       case NEW:
10106       case NEW_DOT:
10107       case NO:
10108       case NONEDITIONABLE:
10109       case NOT:
10110       case NULL:
10111       case NULLIF:
10112       case OBJECT:
10113       case OID:
10114       case OPAQUE:
10115       case OPEN:
10116       case OPERATOR:
10117       case ORGANIZATION:
10118       case OTHERS:
10119       case OVERRIDING:
10120       case PACKAGE:
10121       case PARTITION:
10122       case PRESERVE:
10123       case PRIVATE:
10124       case PROCEDURE:
10125       case RANGE:
10126       case RAW:
10127       case REAL:
10128       case RECORD:
10129       case REF:
10130       case RELEASE:
10131       case RELIES_ON:
10132       case RENAME:
10133       case RESULT:
10134       case RETURN:
10135       case RETURNING:
10136       case REVERSE:
10137       case ROLLBACK:
10138       case ROW:
10139       case ROWS:
10140       case ROWID:
10141       case ROWNUM:
10142       case SAVE:
10143       case SAVEPOINT:
10144       case SECOND:
10145       case SELECT:
10146       case SELF:
10147       case SET:
10148       case SPACE:
10149       case SQL:
10150       case SQLCODE:
10151       case SQLERRM:
10152       case STATIC:
10153       case SUBTYPE:
10154       case SUBSTITUTABLE:
10155       case SUCCESSFUL:
10156       case SYSDATE:
10157       case SYS_REFCURSOR:
10158       case TEMPORARY:
10159       case TIME:
10160       case TIMESTAMP:
10161       case TIMEZONE_REGION:
10162       case TIMEZONE_ABBR:
10163       case TIMEZONE_MINUTE:
10164       case TIMEZONE_HOUR:
10165       case TRANSACTION:
10166       case TRUE:
10167       case TYPE:
10168       case UNDER:
10169       case USING:
10170       case YES:
10171       case SHOW:
10172       case A:
10173       case DOUBLE:
10174       case DEC:
10175       case PRECISION:
10176       case INT:
10177       case NUMERIC:
10178       case NCHAR:
10179       case NVARCHAR2:
10180       case STRING:
10181       case UROWID:
10182       case VARRAY:
10183       case VARYING:
10184       case BFILE:
10185       case BLOB:
10186       case CLOB:
10187       case NCLOB:
10188       case YEAR:
10189       case LOCAL:
10190       case WITH:
10191       case ZONE:
10192       case CHARACTER:
10193       case AFTER:
10194       case BEFORE:
10195       case OLD:
10196       case PARENT:
10197       case CC_IF:
10198       case ANALYZE:
10199       case ASSOCIATE:
10200       case AUDIT:
10201       case COMPOUND:
10202       case DATABASE:
10203       case CALL:
10204       case DDL:
10205       case DISASSOCIATE:
10206       case EACH:
10207       case FOLLOWS:
10208       case LOGOFF:
10209       case LOGON:
10210       case NESTED:
10211       case NOAUDIT:
10212       case SCHEMA:
10213       case SERVERERROR:
10214       case SHUTDOWN:
10215       case STARTUP:
10216       case STATEMENT:
10217       case STATISTICS:
10218       case SUSPEND:
10219       case TRUNCATE:
10220       case WRAPPED:
10221       case LIBRARY:
10222       case NAME:
10223       case STRUCT:
10224       case CONTEXT:
10225       case PARAMETERS:
10226       case LENGTH:
10227       case TDO:
10228       case MAXLEN:
10229       case CHARSETID:
10230       case CHARSETFORM:
10231       case ACCEPT:
10232       case ACCESSIBLE:
10233       case COPY:
10234       case DEFINE:
10235       case DISCONNECT:
10236       case HOST:
10237       case PRINT:
10238       case QUIT:
10239       case REMARK:
10240       case UNDEFINE:
10241       case VARIABLE:
10242       case WHENEVER:
10243       case ATTACH:
10244       case CAST:
10245       case TREAT:
10246       case TRIM:
10247       case LEFT:
10248       case RIGHT:
10249       case BOTH:
10250       case EMPTY:
10251       case MULTISET:
10252       case SUBMULTISET:
10253       case LEADING:
10254       case TRAILING:
10255       case CHAR_CS:
10256       case NCHAR_CS:
10257       case DBTIMEZONE:
10258       case SESSIONTIMEZONE:
10259       case AUTHENTICATED:
10260       case LINK:
10261       case SHARED:
10262       case DIRECTORY:
10263       case USER:
10264       case IDENTIFIER:
10265       case UNSIGNED_NUMERIC_LITERAL:
10266       case CHARACTER_LITERAL:
10267       case STRING_LITERAL:
10268       case QUOTED_LITERAL:
10269         Expression();
10270         break;
10271       default:
10272         jj_la1[123] = jj_gen;
10273         ;
10274       }
10275       label_25:
10276       while (true) {
10277         switch (jj_nt.kind) {
10278         case WHEN:
10279           ;
10280           break;
10281         default:
10282           jj_la1[124] = jj_gen;
10283           break label_25;
10284         }
10285         CaseWhenClause();
10286       }
10287       switch (jj_nt.kind) {
10288       case ELSE:
10289         ElseClause();
10290         break;
10291       default:
10292         jj_la1[125] = jj_gen;
10293         ;
10294       }
10295       jj_consume_token(END);
10296       jj_consume_token(CASE);
10297       switch (jj_nt.kind) {
10298       case IDENTIFIER:
10299         jj_consume_token(IDENTIFIER);
10300         break;
10301       default:
10302         jj_la1[126] = jj_gen;
10303         ;
10304       }
10305         jjtree.closeNodeScope(jjtn000, true);
10306         jjtc000 = false;
10307         {if (true) return jjtn000 ;}
10308     } catch (Throwable jjte000) {
10309          if (jjtc000) {
10310            jjtree.clearNodeScope(jjtn000);
10311            jjtc000 = false;
10312          } else {
10313            jjtree.popNode();
10314          }
10315          if (jjte000 instanceof RuntimeException) {
10316            {if (true) throw (RuntimeException)jjte000;}
10317          }
10318          if (jjte000 instanceof ParseException) {
10319            {if (true) throw (ParseException)jjte000;}
10320          }
10321          {if (true) throw (Error)jjte000;}
10322     } finally {
10323          if (jjtc000) {
10324            jjtree.closeNodeScope(jjtn000, true);
10325          }
10326     }
10327     throw new Error("Missing return statement in function");
10328   }
10329 
10330   final public ASTCaseWhenClause CaseWhenClause() throws ParseException {
10331  /*@bgen(jjtree) CaseWhenClause */
10332   ASTCaseWhenClause jjtn000 = new ASTCaseWhenClause(this, JJTCASEWHENCLAUSE);
10333   boolean jjtc000 = true;
10334   jjtree.openNodeScope(jjtn000);
10335     try {
10336       jj_consume_token(WHEN);
10337       Expression();
10338       jj_consume_token(THEN);
10339       label_26:
10340       while (true) {
10341         Statement();
10342         switch (jj_nt.kind) {
10343         case 5:
10344         case 16:
10345         case 17:
10346         case 21:
10347         case REPLACE:
10348         case DEFINER:
10349         case CURRENT_USER:
10350         case LANGUAGE:
10351         case ADD:
10352         case AGGREGATE:
10353         case ARRAY:
10354         case AT:
10355         case ATTRIBUTE:
10356         case AUTHID:
10357         case BEGIN:
10358         case BODY:
10359         case BULK:
10360         case BYTE:
10361         case CASCADE:
10362         case CASE:
10363         case CLOSE:
10364         case COALESCE:
10365         case COLLECT:
10366         case COLUMN:
10367         case COMMENT:
10368         case COMMIT:
10369         case CONSTRUCTOR:
10370         case CONTINUE:
10371         case CONVERT:
10372         case CURRENT:
10373         case CURSOR:
10374         case DATA:
10375         case DATE:
10376         case DAY:
10377         case DECLARE:
10378         case DELETE:
10379         case DISABLE:
10380         case EDITIONABLE:
10381         case ELEMENT:
10382         case ENABLE:
10383         case ESCAPE:
10384         case EXCEPT:
10385         case EXCEPTIONS:
10386         case EXECUTE:
10387         case EXIT:
10388         case EXTERNAL:
10389         case EXTENDS:
10390         case EXTRACT:
10391         case FALSE:
10392         case FETCH:
10393         case FINAL:
10394         case FOR:
10395         case FORALL:
10396         case FORCE:
10397         case FUNCTION:
10398         case GLOBAL:
10399         case GOTO:
10400         case HASH:
10401         case HEAP:
10402         case HOUR:
10403         case IF:
10404         case IMMEDIATE:
10405         case INDICES:
10406         case INDEXTYPE:
10407         case INDICATOR:
10408         case INSERT:
10409         case INSTANTIABLE:
10410         case INTERVAL:
10411         case INVALIDATE:
10412         case ISOLATION:
10413         case JAVA:
10414         case LEVEL:
10415         case LIMIT:
10416         case LOCK:
10417         case LOOP:
10418         case MAP:
10419         case MAX:
10420         case MEMBER:
10421         case MERGE:
10422         case MIN:
10423         case MINUTE:
10424         case MLSLABEL:
10425         case MODIFY:
10426         case MOD:
10427         case MONTH:
10428         case NATURAL:
10429         case NEW:
10430         case NEW_DOT:
10431         case NO:
10432         case NONEDITIONABLE:
10433         case NOT:
10434         case NULL:
10435         case NULLIF:
10436         case OBJECT:
10437         case OID:
10438         case OPAQUE:
10439         case OPEN:
10440         case OPERATOR:
10441         case ORGANIZATION:
10442         case OTHERS:
10443         case OVERRIDING:
10444         case PACKAGE:
10445         case PARTITION:
10446         case PIPE:
10447         case PRESERVE:
10448         case PRIVATE:
10449         case PROCEDURE:
10450         case RAISE:
10451         case RANGE:
10452         case RAW:
10453         case REAL:
10454         case RECORD:
10455         case REF:
10456         case RELEASE:
10457         case RELIES_ON:
10458         case RENAME:
10459         case RESULT:
10460         case RETURN:
10461         case RETURNING:
10462         case REVERSE:
10463         case ROLLBACK:
10464         case ROW:
10465         case ROWS:
10466         case ROWID:
10467         case ROWNUM:
10468         case SAVE:
10469         case SAVEPOINT:
10470         case SECOND:
10471         case SELECT:
10472         case SELF:
10473         case SET:
10474         case SPACE:
10475         case SQL:
10476         case SQLCODE:
10477         case SQLERRM:
10478         case STATIC:
10479         case SUBTYPE:
10480         case SUBSTITUTABLE:
10481         case SUCCESSFUL:
10482         case SYSDATE:
10483         case SYS_REFCURSOR:
10484         case TEMPORARY:
10485         case TIME:
10486         case TIMESTAMP:
10487         case TIMEZONE_REGION:
10488         case TIMEZONE_ABBR:
10489         case TIMEZONE_MINUTE:
10490         case TIMEZONE_HOUR:
10491         case TRANSACTION:
10492         case TRUE:
10493         case TYPE:
10494         case UNDER:
10495         case USING:
10496         case WHILE:
10497         case YES:
10498         case SHOW:
10499         case A:
10500         case UPDATE:
10501         case DOUBLE:
10502         case DEC:
10503         case PRECISION:
10504         case INT:
10505         case NUMERIC:
10506         case NCHAR:
10507         case NVARCHAR2:
10508         case STRING:
10509         case UROWID:
10510         case VARRAY:
10511         case VARYING:
10512         case BFILE:
10513         case BLOB:
10514         case CLOB:
10515         case NCLOB:
10516         case YEAR:
10517         case LOCAL:
10518         case WITH:
10519         case ZONE:
10520         case CHARACTER:
10521         case AFTER:
10522         case BEFORE:
10523         case OLD:
10524         case PARENT:
10525         case CC_IF:
10526         case CC_ERROR:
10527         case ANALYZE:
10528         case ASSOCIATE:
10529         case AUDIT:
10530         case COMPOUND:
10531         case DATABASE:
10532         case CALL:
10533         case DDL:
10534         case DISASSOCIATE:
10535         case EACH:
10536         case FOLLOWS:
10537         case LOGOFF:
10538         case LOGON:
10539         case NESTED:
10540         case NOAUDIT:
10541         case SCHEMA:
10542         case SERVERERROR:
10543         case SHUTDOWN:
10544         case STARTUP:
10545         case STATEMENT:
10546         case STATISTICS:
10547         case SUSPEND:
10548         case TRUNCATE:
10549         case WRAPPED:
10550         case LIBRARY:
10551         case NAME:
10552         case STRUCT:
10553         case CONTEXT:
10554         case PARAMETERS:
10555         case LENGTH:
10556         case TDO:
10557         case MAXLEN:
10558         case CHARSETID:
10559         case CHARSETFORM:
10560         case ACCEPT:
10561         case ACCESSIBLE:
10562         case COPY:
10563         case DEFINE:
10564         case DISCONNECT:
10565         case HOST:
10566         case PRINT:
10567         case QUIT:
10568         case REMARK:
10569         case UNDEFINE:
10570         case VARIABLE:
10571         case WHENEVER:
10572         case ATTACH:
10573         case CAST:
10574         case TREAT:
10575         case TRIM:
10576         case LEFT:
10577         case RIGHT:
10578         case BOTH:
10579         case EMPTY:
10580         case MULTISET:
10581         case SUBMULTISET:
10582         case LEADING:
10583         case TRAILING:
10584         case CHAR_CS:
10585         case NCHAR_CS:
10586         case DBTIMEZONE:
10587         case SESSIONTIMEZONE:
10588         case AUTHENTICATED:
10589         case LINK:
10590         case SHARED:
10591         case DIRECTORY:
10592         case USER:
10593         case IDENTIFIER:
10594         case UNSIGNED_NUMERIC_LITERAL:
10595         case CHARACTER_LITERAL:
10596         case STRING_LITERAL:
10597         case QUOTED_LITERAL:
10598           ;
10599           break;
10600         default:
10601           jj_la1[127] = jj_gen;
10602           break label_26;
10603         }
10604       }
10605         jjtree.closeNodeScope(jjtn000, true);
10606         jjtc000 = false;
10607         {if (true) return jjtn000 ;}
10608     } catch (Throwable jjte000) {
10609           if (jjtc000) {
10610             jjtree.clearNodeScope(jjtn000);
10611             jjtc000 = false;
10612           } else {
10613             jjtree.popNode();
10614           }
10615           if (jjte000 instanceof RuntimeException) {
10616             {if (true) throw (RuntimeException)jjte000;}
10617           }
10618           if (jjte000 instanceof ParseException) {
10619             {if (true) throw (ParseException)jjte000;}
10620           }
10621           {if (true) throw (Error)jjte000;}
10622     } finally {
10623           if (jjtc000) {
10624             jjtree.closeNodeScope(jjtn000, true);
10625           }
10626     }
10627     throw new Error("Missing return statement in function");
10628   }
10629 
10630   final public ASTElseClause ElseClause() throws ParseException {
10631  /*@bgen(jjtree) ElseClause */
10632   ASTElseClause jjtn000 = new ASTElseClause(this, JJTELSECLAUSE);
10633   boolean jjtc000 = true;
10634   jjtree.openNodeScope(jjtn000);
10635     try {
10636       jj_consume_token(ELSE);
10637       label_27:
10638       while (true) {
10639         Statement();
10640         switch (jj_nt.kind) {
10641         case 5:
10642         case 16:
10643         case 17:
10644         case 21:
10645         case REPLACE:
10646         case DEFINER:
10647         case CURRENT_USER:
10648         case LANGUAGE:
10649         case ADD:
10650         case AGGREGATE:
10651         case ARRAY:
10652         case AT:
10653         case ATTRIBUTE:
10654         case AUTHID:
10655         case BEGIN:
10656         case BODY:
10657         case BULK:
10658         case BYTE:
10659         case CASCADE:
10660         case CASE:
10661         case CLOSE:
10662         case COALESCE:
10663         case COLLECT:
10664         case COLUMN:
10665         case COMMENT:
10666         case COMMIT:
10667         case CONSTRUCTOR:
10668         case CONTINUE:
10669         case CONVERT:
10670         case CURRENT:
10671         case CURSOR:
10672         case DATA:
10673         case DATE:
10674         case DAY:
10675         case DECLARE:
10676         case DELETE:
10677         case DISABLE:
10678         case EDITIONABLE:
10679         case ELEMENT:
10680         case ENABLE:
10681         case ESCAPE:
10682         case EXCEPT:
10683         case EXCEPTIONS:
10684         case EXECUTE:
10685         case EXIT:
10686         case EXTERNAL:
10687         case EXTENDS:
10688         case EXTRACT:
10689         case FALSE:
10690         case FETCH:
10691         case FINAL:
10692         case FOR:
10693         case FORALL:
10694         case FORCE:
10695         case FUNCTION:
10696         case GLOBAL:
10697         case GOTO:
10698         case HASH:
10699         case HEAP:
10700         case HOUR:
10701         case IF:
10702         case IMMEDIATE:
10703         case INDICES:
10704         case INDEXTYPE:
10705         case INDICATOR:
10706         case INSERT:
10707         case INSTANTIABLE:
10708         case INTERVAL:
10709         case INVALIDATE:
10710         case ISOLATION:
10711         case JAVA:
10712         case LEVEL:
10713         case LIMIT:
10714         case LOCK:
10715         case LOOP:
10716         case MAP:
10717         case MAX:
10718         case MEMBER:
10719         case MERGE:
10720         case MIN:
10721         case MINUTE:
10722         case MLSLABEL:
10723         case MODIFY:
10724         case MOD:
10725         case MONTH:
10726         case NATURAL:
10727         case NEW:
10728         case NEW_DOT:
10729         case NO:
10730         case NONEDITIONABLE:
10731         case NOT:
10732         case NULL:
10733         case NULLIF:
10734         case OBJECT:
10735         case OID:
10736         case OPAQUE:
10737         case OPEN:
10738         case OPERATOR:
10739         case ORGANIZATION:
10740         case OTHERS:
10741         case OVERRIDING:
10742         case PACKAGE:
10743         case PARTITION:
10744         case PIPE:
10745         case PRESERVE:
10746         case PRIVATE:
10747         case PROCEDURE:
10748         case RAISE:
10749         case RANGE:
10750         case RAW:
10751         case REAL:
10752         case RECORD:
10753         case REF:
10754         case RELEASE:
10755         case RELIES_ON:
10756         case RENAME:
10757         case RESULT:
10758         case RETURN:
10759         case RETURNING:
10760         case REVERSE:
10761         case ROLLBACK:
10762         case ROW:
10763         case ROWS:
10764         case ROWID:
10765         case ROWNUM:
10766         case SAVE:
10767         case SAVEPOINT:
10768         case SECOND:
10769         case SELECT:
10770         case SELF:
10771         case SET:
10772         case SPACE:
10773         case SQL:
10774         case SQLCODE:
10775         case SQLERRM:
10776         case STATIC:
10777         case SUBTYPE:
10778         case SUBSTITUTABLE:
10779         case SUCCESSFUL:
10780         case SYSDATE:
10781         case SYS_REFCURSOR:
10782         case TEMPORARY:
10783         case TIME:
10784         case TIMESTAMP:
10785         case TIMEZONE_REGION:
10786         case TIMEZONE_ABBR:
10787         case TIMEZONE_MINUTE:
10788         case TIMEZONE_HOUR:
10789         case TRANSACTION:
10790         case TRUE:
10791         case TYPE:
10792         case UNDER:
10793         case USING:
10794         case WHILE:
10795         case YES:
10796         case SHOW:
10797         case A:
10798         case UPDATE:
10799         case DOUBLE:
10800         case DEC:
10801         case PRECISION:
10802         case INT:
10803         case NUMERIC:
10804         case NCHAR:
10805         case NVARCHAR2:
10806         case STRING:
10807         case UROWID:
10808         case VARRAY:
10809         case VARYING:
10810         case BFILE:
10811         case BLOB:
10812         case CLOB:
10813         case NCLOB:
10814         case YEAR:
10815         case LOCAL:
10816         case WITH:
10817         case ZONE:
10818         case CHARACTER:
10819         case AFTER:
10820         case BEFORE:
10821         case OLD:
10822         case PARENT:
10823         case CC_IF:
10824         case CC_ERROR:
10825         case ANALYZE:
10826         case ASSOCIATE:
10827         case AUDIT:
10828         case COMPOUND:
10829         case DATABASE:
10830         case CALL:
10831         case DDL:
10832         case DISASSOCIATE:
10833         case EACH:
10834         case FOLLOWS:
10835         case LOGOFF:
10836         case LOGON:
10837         case NESTED:
10838         case NOAUDIT:
10839         case SCHEMA:
10840         case SERVERERROR:
10841         case SHUTDOWN:
10842         case STARTUP:
10843         case STATEMENT:
10844         case STATISTICS:
10845         case SUSPEND:
10846         case TRUNCATE:
10847         case WRAPPED:
10848         case LIBRARY:
10849         case NAME:
10850         case STRUCT:
10851         case CONTEXT:
10852         case PARAMETERS:
10853         case LENGTH:
10854         case TDO:
10855         case MAXLEN:
10856         case CHARSETID:
10857         case CHARSETFORM:
10858         case ACCEPT:
10859         case ACCESSIBLE:
10860         case COPY:
10861         case DEFINE:
10862         case DISCONNECT:
10863         case HOST:
10864         case PRINT:
10865         case QUIT:
10866         case REMARK:
10867         case UNDEFINE:
10868         case VARIABLE:
10869         case WHENEVER:
10870         case ATTACH:
10871         case CAST:
10872         case TREAT:
10873         case TRIM:
10874         case LEFT:
10875         case RIGHT:
10876         case BOTH:
10877         case EMPTY:
10878         case MULTISET:
10879         case SUBMULTISET:
10880         case LEADING:
10881         case TRAILING:
10882         case CHAR_CS:
10883         case NCHAR_CS:
10884         case DBTIMEZONE:
10885         case SESSIONTIMEZONE:
10886         case AUTHENTICATED:
10887         case LINK:
10888         case SHARED:
10889         case DIRECTORY:
10890         case USER:
10891         case IDENTIFIER:
10892         case UNSIGNED_NUMERIC_LITERAL:
10893         case CHARACTER_LITERAL:
10894         case STRING_LITERAL:
10895         case QUOTED_LITERAL:
10896           ;
10897           break;
10898         default:
10899           jj_la1[128] = jj_gen;
10900           break label_27;
10901         }
10902       }
10903         jjtree.closeNodeScope(jjtn000, true);
10904         jjtc000 = false;
10905         {if (true) return jjtn000 ;}
10906     } catch (Throwable jjte000) {
10907           if (jjtc000) {
10908             jjtree.clearNodeScope(jjtn000);
10909             jjtc000 = false;
10910           } else {
10911             jjtree.popNode();
10912           }
10913           if (jjte000 instanceof RuntimeException) {
10914             {if (true) throw (RuntimeException)jjte000;}
10915           }
10916           if (jjte000 instanceof ParseException) {
10917             {if (true) throw (ParseException)jjte000;}
10918           }
10919           {if (true) throw (Error)jjte000;}
10920     } finally {
10921           if (jjtc000) {
10922             jjtree.closeNodeScope(jjtn000, true);
10923           }
10924     }
10925     throw new Error("Missing return statement in function");
10926   }
10927 
10928   final public ASTElsifClause ElsifClause() throws ParseException {
10929  /*@bgen(jjtree) ElsifClause */
10930   ASTElsifClause jjtn000 = new ASTElsifClause(this, JJTELSIFCLAUSE);
10931   boolean jjtc000 = true;
10932   jjtree.openNodeScope(jjtn000);
10933     try {
10934       jj_consume_token(ELSIF);
10935       Expression();
10936       jj_consume_token(THEN);
10937       label_28:
10938       while (true) {
10939         Statement();
10940         switch (jj_nt.kind) {
10941         case 5:
10942         case 16:
10943         case 17:
10944         case 21:
10945         case REPLACE:
10946         case DEFINER:
10947         case CURRENT_USER:
10948         case LANGUAGE:
10949         case ADD:
10950         case AGGREGATE:
10951         case ARRAY:
10952         case AT:
10953         case ATTRIBUTE:
10954         case AUTHID:
10955         case BEGIN:
10956         case BODY:
10957         case BULK:
10958         case BYTE:
10959         case CASCADE:
10960         case CASE:
10961         case CLOSE:
10962         case COALESCE:
10963         case COLLECT:
10964         case COLUMN:
10965         case COMMENT:
10966         case COMMIT:
10967         case CONSTRUCTOR:
10968         case CONTINUE:
10969         case CONVERT:
10970         case CURRENT:
10971         case CURSOR:
10972         case DATA:
10973         case DATE:
10974         case DAY:
10975         case DECLARE:
10976         case DELETE:
10977         case DISABLE:
10978         case EDITIONABLE:
10979         case ELEMENT:
10980         case ENABLE:
10981         case ESCAPE:
10982         case EXCEPT:
10983         case EXCEPTIONS:
10984         case EXECUTE:
10985         case EXIT:
10986         case EXTERNAL:
10987         case EXTENDS:
10988         case EXTRACT:
10989         case FALSE:
10990         case FETCH:
10991         case FINAL:
10992         case FOR:
10993         case FORALL:
10994         case FORCE:
10995         case FUNCTION:
10996         case GLOBAL:
10997         case GOTO:
10998         case HASH:
10999         case HEAP:
11000         case HOUR:
11001         case IF:
11002         case IMMEDIATE:
11003         case INDICES:
11004         case INDEXTYPE:
11005         case INDICATOR:
11006         case INSERT:
11007         case INSTANTIABLE:
11008         case INTERVAL:
11009         case INVALIDATE:
11010         case ISOLATION:
11011         case JAVA:
11012         case LEVEL:
11013         case LIMIT:
11014         case LOCK:
11015         case LOOP:
11016         case MAP:
11017         case MAX:
11018         case MEMBER:
11019         case MERGE:
11020         case MIN:
11021         case MINUTE:
11022         case MLSLABEL:
11023         case MODIFY:
11024         case MOD:
11025         case MONTH:
11026         case NATURAL:
11027         case NEW:
11028         case NEW_DOT:
11029         case NO:
11030         case NONEDITIONABLE:
11031         case NOT:
11032         case NULL:
11033         case NULLIF:
11034         case OBJECT:
11035         case OID:
11036         case OPAQUE:
11037         case OPEN:
11038         case OPERATOR:
11039         case ORGANIZATION:
11040         case OTHERS:
11041         case OVERRIDING:
11042         case PACKAGE:
11043         case PARTITION:
11044         case PIPE:
11045         case PRESERVE:
11046         case PRIVATE:
11047         case PROCEDURE:
11048         case RAISE:
11049         case RANGE:
11050         case RAW:
11051         case REAL:
11052         case RECORD:
11053         case REF:
11054         case RELEASE:
11055         case RELIES_ON:
11056         case RENAME:
11057         case RESULT:
11058         case RETURN:
11059         case RETURNING:
11060         case REVERSE:
11061         case ROLLBACK:
11062         case ROW:
11063         case ROWS:
11064         case ROWID:
11065         case ROWNUM:
11066         case SAVE:
11067         case SAVEPOINT:
11068         case SECOND:
11069         case SELECT:
11070         case SELF:
11071         case SET:
11072         case SPACE:
11073         case SQL:
11074         case SQLCODE:
11075         case SQLERRM:
11076         case STATIC:
11077         case SUBTYPE:
11078         case SUBSTITUTABLE:
11079         case SUCCESSFUL:
11080         case SYSDATE:
11081         case SYS_REFCURSOR:
11082         case TEMPORARY:
11083         case TIME:
11084         case TIMESTAMP:
11085         case TIMEZONE_REGION:
11086         case TIMEZONE_ABBR:
11087         case TIMEZONE_MINUTE:
11088         case TIMEZONE_HOUR:
11089         case TRANSACTION:
11090         case TRUE:
11091         case TYPE:
11092         case UNDER:
11093         case USING:
11094         case WHILE:
11095         case YES:
11096         case SHOW:
11097         case A:
11098         case UPDATE:
11099         case DOUBLE:
11100         case DEC:
11101         case PRECISION:
11102         case INT:
11103         case NUMERIC:
11104         case NCHAR:
11105         case NVARCHAR2:
11106         case STRING:
11107         case UROWID:
11108         case VARRAY:
11109         case VARYING:
11110         case BFILE:
11111         case BLOB:
11112         case CLOB:
11113         case NCLOB:
11114         case YEAR:
11115         case LOCAL:
11116         case WITH:
11117         case ZONE:
11118         case CHARACTER:
11119         case AFTER:
11120         case BEFORE:
11121         case OLD:
11122         case PARENT:
11123         case CC_IF:
11124         case CC_ERROR:
11125         case ANALYZE:
11126         case ASSOCIATE:
11127         case AUDIT:
11128         case COMPOUND:
11129         case DATABASE:
11130         case CALL:
11131         case DDL:
11132         case DISASSOCIATE:
11133         case EACH:
11134         case FOLLOWS:
11135         case LOGOFF:
11136         case LOGON:
11137         case NESTED:
11138         case NOAUDIT:
11139         case SCHEMA:
11140         case SERVERERROR:
11141         case SHUTDOWN:
11142         case STARTUP:
11143         case STATEMENT:
11144         case STATISTICS:
11145         case SUSPEND:
11146         case TRUNCATE:
11147         case WRAPPED:
11148         case LIBRARY:
11149         case NAME:
11150         case STRUCT:
11151         case CONTEXT:
11152         case PARAMETERS:
11153         case LENGTH:
11154         case TDO:
11155         case MAXLEN:
11156         case CHARSETID:
11157         case CHARSETFORM:
11158         case ACCEPT:
11159         case ACCESSIBLE:
11160         case COPY:
11161         case DEFINE:
11162         case DISCONNECT:
11163         case HOST:
11164         case PRINT:
11165         case QUIT:
11166         case REMARK:
11167         case UNDEFINE:
11168         case VARIABLE:
11169         case WHENEVER:
11170         case ATTACH:
11171         case CAST:
11172         case TREAT:
11173         case TRIM:
11174         case LEFT:
11175         case RIGHT:
11176         case BOTH:
11177         case EMPTY:
11178         case MULTISET:
11179         case SUBMULTISET:
11180         case LEADING:
11181         case TRAILING:
11182         case CHAR_CS:
11183         case NCHAR_CS:
11184         case DBTIMEZONE:
11185         case SESSIONTIMEZONE:
11186         case AUTHENTICATED:
11187         case LINK:
11188         case SHARED:
11189         case DIRECTORY:
11190         case USER:
11191         case IDENTIFIER:
11192         case UNSIGNED_NUMERIC_LITERAL:
11193         case CHARACTER_LITERAL:
11194         case STRING_LITERAL:
11195         case QUOTED_LITERAL:
11196           ;
11197           break;
11198         default:
11199           jj_la1[129] = jj_gen;
11200           break label_28;
11201         }
11202       }
11203         jjtree.closeNodeScope(jjtn000, true);
11204         jjtc000 = false;
11205         {if (true) return jjtn000 ;}
11206     } catch (Throwable jjte000) {
11207         if (jjtc000) {
11208           jjtree.clearNodeScope(jjtn000);
11209           jjtc000 = false;
11210         } else {
11211           jjtree.popNode();
11212         }
11213         if (jjte000 instanceof RuntimeException) {
11214           {if (true) throw (RuntimeException)jjte000;}
11215         }
11216         if (jjte000 instanceof ParseException) {
11217           {if (true) throw (ParseException)jjte000;}
11218         }
11219         {if (true) throw (Error)jjte000;}
11220     } finally {
11221         if (jjtc000) {
11222           jjtree.closeNodeScope(jjtn000, true);
11223         }
11224     }
11225     throw new Error("Missing return statement in function");
11226   }
11227 
11228   final public ASTLoopStatement LoopStatement() throws ParseException {
11229  /*@bgen(jjtree) LoopStatement */
11230   ASTLoopStatement jjtn000 = new ASTLoopStatement(this, JJTLOOPSTATEMENT);
11231   boolean jjtc000 = true;
11232   jjtree.openNodeScope(jjtn000);
11233     try {
11234       jj_consume_token(LOOP);
11235       label_29:
11236       while (true) {
11237         Statement();
11238         switch (jj_nt.kind) {
11239         case 5:
11240         case 16:
11241         case 17:
11242         case 21:
11243         case REPLACE:
11244         case DEFINER:
11245         case CURRENT_USER:
11246         case LANGUAGE:
11247         case ADD:
11248         case AGGREGATE:
11249         case ARRAY:
11250         case AT:
11251         case ATTRIBUTE:
11252         case AUTHID:
11253         case BEGIN:
11254         case BODY:
11255         case BULK:
11256         case BYTE:
11257         case CASCADE:
11258         case CASE:
11259         case CLOSE:
11260         case COALESCE:
11261         case COLLECT:
11262         case COLUMN:
11263         case COMMENT:
11264         case COMMIT:
11265         case CONSTRUCTOR:
11266         case CONTINUE:
11267         case CONVERT:
11268         case CURRENT:
11269         case CURSOR:
11270         case DATA:
11271         case DATE:
11272         case DAY:
11273         case DECLARE:
11274         case DELETE:
11275         case DISABLE:
11276         case EDITIONABLE:
11277         case ELEMENT:
11278         case ENABLE:
11279         case ESCAPE:
11280         case EXCEPT:
11281         case EXCEPTIONS:
11282         case EXECUTE:
11283         case EXIT:
11284         case EXTERNAL:
11285         case EXTENDS:
11286         case EXTRACT:
11287         case FALSE:
11288         case FETCH:
11289         case FINAL:
11290         case FOR:
11291         case FORALL:
11292         case FORCE:
11293         case FUNCTION:
11294         case GLOBAL:
11295         case GOTO:
11296         case HASH:
11297         case HEAP:
11298         case HOUR:
11299         case IF:
11300         case IMMEDIATE:
11301         case INDICES:
11302         case INDEXTYPE:
11303         case INDICATOR:
11304         case INSERT:
11305         case INSTANTIABLE:
11306         case INTERVAL:
11307         case INVALIDATE:
11308         case ISOLATION:
11309         case JAVA:
11310         case LEVEL:
11311         case LIMIT:
11312         case LOCK:
11313         case LOOP:
11314         case MAP:
11315         case MAX:
11316         case MEMBER:
11317         case MERGE:
11318         case MIN:
11319         case MINUTE:
11320         case MLSLABEL:
11321         case MODIFY:
11322         case MOD:
11323         case MONTH:
11324         case NATURAL:
11325         case NEW:
11326         case NEW_DOT:
11327         case NO:
11328         case NONEDITIONABLE:
11329         case NOT:
11330         case NULL:
11331         case NULLIF:
11332         case OBJECT:
11333         case OID:
11334         case OPAQUE:
11335         case OPEN:
11336         case OPERATOR:
11337         case ORGANIZATION:
11338         case OTHERS:
11339         case OVERRIDING:
11340         case PACKAGE:
11341         case PARTITION:
11342         case PIPE:
11343         case PRESERVE:
11344         case PRIVATE:
11345         case PROCEDURE:
11346         case RAISE:
11347         case RANGE:
11348         case RAW:
11349         case REAL:
11350         case RECORD:
11351         case REF:
11352         case RELEASE:
11353         case RELIES_ON:
11354         case RENAME:
11355         case RESULT:
11356         case RETURN:
11357         case RETURNING:
11358         case REVERSE:
11359         case ROLLBACK:
11360         case ROW:
11361         case ROWS:
11362         case ROWID:
11363         case ROWNUM:
11364         case SAVE:
11365         case SAVEPOINT:
11366         case SECOND:
11367         case SELECT:
11368         case SELF:
11369         case SET:
11370         case SPACE:
11371         case SQL:
11372         case SQLCODE:
11373         case SQLERRM:
11374         case STATIC:
11375         case SUBTYPE:
11376         case SUBSTITUTABLE:
11377         case SUCCESSFUL:
11378         case SYSDATE:
11379         case SYS_REFCURSOR:
11380         case TEMPORARY:
11381         case TIME:
11382         case TIMESTAMP:
11383         case TIMEZONE_REGION:
11384         case TIMEZONE_ABBR:
11385         case TIMEZONE_MINUTE:
11386         case TIMEZONE_HOUR:
11387         case TRANSACTION:
11388         case TRUE:
11389         case TYPE:
11390         case UNDER:
11391         case USING:
11392         case WHILE:
11393         case YES:
11394         case SHOW:
11395         case A:
11396         case UPDATE:
11397         case DOUBLE:
11398         case DEC:
11399         case PRECISION:
11400         case INT:
11401         case NUMERIC:
11402         case NCHAR:
11403         case NVARCHAR2:
11404         case STRING:
11405         case UROWID:
11406         case VARRAY:
11407         case VARYING:
11408         case BFILE:
11409         case BLOB:
11410         case CLOB:
11411         case NCLOB:
11412         case YEAR:
11413         case LOCAL:
11414         case WITH:
11415         case ZONE:
11416         case CHARACTER:
11417         case AFTER:
11418         case BEFORE:
11419         case OLD:
11420         case PARENT:
11421         case CC_IF:
11422         case CC_ERROR:
11423         case ANALYZE:
11424         case ASSOCIATE:
11425         case AUDIT:
11426         case COMPOUND:
11427         case DATABASE:
11428         case CALL:
11429         case DDL:
11430         case DISASSOCIATE:
11431         case EACH:
11432         case FOLLOWS:
11433         case LOGOFF:
11434         case LOGON:
11435         case NESTED:
11436         case NOAUDIT:
11437         case SCHEMA:
11438         case SERVERERROR:
11439         case SHUTDOWN:
11440         case STARTUP:
11441         case STATEMENT:
11442         case STATISTICS:
11443         case SUSPEND:
11444         case TRUNCATE:
11445         case WRAPPED:
11446         case LIBRARY:
11447         case NAME:
11448         case STRUCT:
11449         case CONTEXT:
11450         case PARAMETERS:
11451         case LENGTH:
11452         case TDO:
11453         case MAXLEN:
11454         case CHARSETID:
11455         case CHARSETFORM:
11456         case ACCEPT:
11457         case ACCESSIBLE:
11458         case COPY:
11459         case DEFINE:
11460         case DISCONNECT:
11461         case HOST:
11462         case PRINT:
11463         case QUIT:
11464         case REMARK:
11465         case UNDEFINE:
11466         case VARIABLE:
11467         case WHENEVER:
11468         case ATTACH:
11469         case CAST:
11470         case TREAT:
11471         case TRIM:
11472         case LEFT:
11473         case RIGHT:
11474         case BOTH:
11475         case EMPTY:
11476         case MULTISET:
11477         case SUBMULTISET:
11478         case LEADING:
11479         case TRAILING:
11480         case CHAR_CS:
11481         case NCHAR_CS:
11482         case DBTIMEZONE:
11483         case SESSIONTIMEZONE:
11484         case AUTHENTICATED:
11485         case LINK:
11486         case SHARED:
11487         case DIRECTORY:
11488         case USER:
11489         case IDENTIFIER:
11490         case UNSIGNED_NUMERIC_LITERAL:
11491         case CHARACTER_LITERAL:
11492         case STRING_LITERAL:
11493         case QUOTED_LITERAL:
11494           ;
11495           break;
11496         default:
11497           jj_la1[130] = jj_gen;
11498           break label_29;
11499         }
11500       }
11501       jj_consume_token(END);
11502       jj_consume_token(LOOP);
11503       switch (jj_nt.kind) {
11504       case IDENTIFIER:
11505         jj_consume_token(IDENTIFIER);
11506         break;
11507       default:
11508         jj_la1[131] = jj_gen;
11509         ;
11510       }
11511         jjtree.closeNodeScope(jjtn000, true);
11512         jjtc000 = false;
11513         {if (true) return jjtn000 ;}
11514     } catch (Throwable jjte000) {
11515          if (jjtc000) {
11516            jjtree.clearNodeScope(jjtn000);
11517            jjtc000 = false;
11518          } else {
11519            jjtree.popNode();
11520          }
11521          if (jjte000 instanceof RuntimeException) {
11522            {if (true) throw (RuntimeException)jjte000;}
11523          }
11524          if (jjte000 instanceof ParseException) {
11525            {if (true) throw (ParseException)jjte000;}
11526          }
11527          {if (true) throw (Error)jjte000;}
11528     } finally {
11529          if (jjtc000) {
11530            jjtree.closeNodeScope(jjtn000, true);
11531          }
11532     }
11533     throw new Error("Missing return statement in function");
11534   }
11535 
11536 /** Scope rule: the loop index only exists within the Loop */
11537   final public ASTForStatement ForStatement() throws ParseException {
11538  /*@bgen(jjtree) ForStatement */
11539   ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT);
11540   boolean jjtc000 = true;
11541   jjtree.openNodeScope(jjtn000);
11542     try {
11543       jj_consume_token(FOR);
11544       ForIndex();
11545       jj_consume_token(IN);
11546       switch (jj_nt.kind) {
11547       case REVERSE:
11548         jj_consume_token(REVERSE);
11549         break;
11550       default:
11551         jj_la1[132] = jj_gen;
11552         ;
11553       }
11554       Expression();
11555       switch (jj_nt.kind) {
11556       case 12:
11557         jj_consume_token(12);
11558         Expression();
11559         break;
11560       default:
11561         jj_la1[133] = jj_gen;
11562         ;
11563       }
11564       jj_consume_token(LOOP);
11565       label_30:
11566       while (true) {
11567         Statement();
11568         switch (jj_nt.kind) {
11569         case 5:
11570         case 16:
11571         case 17:
11572         case 21:
11573         case REPLACE:
11574         case DEFINER:
11575         case CURRENT_USER:
11576         case LANGUAGE:
11577         case ADD:
11578         case AGGREGATE:
11579         case ARRAY:
11580         case AT:
11581         case ATTRIBUTE:
11582         case AUTHID:
11583         case BEGIN:
11584         case BODY:
11585         case BULK:
11586         case BYTE:
11587         case CASCADE:
11588         case CASE:
11589         case CLOSE:
11590         case COALESCE:
11591         case COLLECT:
11592         case COLUMN:
11593         case COMMENT:
11594         case COMMIT:
11595         case CONSTRUCTOR:
11596         case CONTINUE:
11597         case CONVERT:
11598         case CURRENT:
11599         case CURSOR:
11600         case DATA:
11601         case DATE:
11602         case DAY:
11603         case DECLARE:
11604         case DELETE:
11605         case DISABLE:
11606         case EDITIONABLE:
11607         case ELEMENT:
11608         case ENABLE:
11609         case ESCAPE:
11610         case EXCEPT:
11611         case EXCEPTIONS:
11612         case EXECUTE:
11613         case EXIT:
11614         case EXTERNAL:
11615         case EXTENDS:
11616         case EXTRACT:
11617         case FALSE:
11618         case FETCH:
11619         case FINAL:
11620         case FOR:
11621         case FORALL:
11622         case FORCE:
11623         case FUNCTION:
11624         case GLOBAL:
11625         case GOTO:
11626         case HASH:
11627         case HEAP:
11628         case HOUR:
11629         case IF:
11630         case IMMEDIATE:
11631         case INDICES:
11632         case INDEXTYPE:
11633         case INDICATOR:
11634         case INSERT:
11635         case INSTANTIABLE:
11636         case INTERVAL:
11637         case INVALIDATE:
11638         case ISOLATION:
11639         case JAVA:
11640         case LEVEL:
11641         case LIMIT:
11642         case LOCK:
11643         case LOOP:
11644         case MAP:
11645         case MAX:
11646         case MEMBER:
11647         case MERGE:
11648         case MIN:
11649         case MINUTE:
11650         case MLSLABEL:
11651         case MODIFY:
11652         case MOD:
11653         case MONTH:
11654         case NATURAL:
11655         case NEW:
11656         case NEW_DOT:
11657         case NO:
11658         case NONEDITIONABLE:
11659         case NOT:
11660         case NULL:
11661         case NULLIF:
11662         case OBJECT:
11663         case OID:
11664         case OPAQUE:
11665         case OPEN:
11666         case OPERATOR:
11667         case ORGANIZATION:
11668         case OTHERS:
11669         case OVERRIDING:
11670         case PACKAGE:
11671         case PARTITION:
11672         case PIPE:
11673         case PRESERVE:
11674         case PRIVATE:
11675         case PROCEDURE:
11676         case RAISE:
11677         case RANGE:
11678         case RAW:
11679         case REAL:
11680         case RECORD:
11681         case REF:
11682         case RELEASE:
11683         case RELIES_ON:
11684         case RENAME:
11685         case RESULT:
11686         case RETURN:
11687         case RETURNING:
11688         case REVERSE:
11689         case ROLLBACK:
11690         case ROW:
11691         case ROWS:
11692         case ROWID:
11693         case ROWNUM:
11694         case SAVE:
11695         case SAVEPOINT:
11696         case SECOND:
11697         case SELECT:
11698         case SELF:
11699         case SET:
11700         case SPACE:
11701         case SQL:
11702         case SQLCODE:
11703         case SQLERRM:
11704         case STATIC:
11705         case SUBTYPE:
11706         case SUBSTITUTABLE:
11707         case SUCCESSFUL:
11708         case SYSDATE:
11709         case SYS_REFCURSOR:
11710         case TEMPORARY:
11711         case TIME:
11712         case TIMESTAMP:
11713         case TIMEZONE_REGION:
11714         case TIMEZONE_ABBR:
11715         case TIMEZONE_MINUTE:
11716         case TIMEZONE_HOUR:
11717         case TRANSACTION:
11718         case TRUE:
11719         case TYPE:
11720         case UNDER:
11721         case USING:
11722         case WHILE:
11723         case YES:
11724         case SHOW:
11725         case A:
11726         case UPDATE:
11727         case DOUBLE:
11728         case DEC:
11729         case PRECISION:
11730         case INT:
11731         case NUMERIC:
11732         case NCHAR:
11733         case NVARCHAR2:
11734         case STRING:
11735         case UROWID:
11736         case VARRAY:
11737         case VARYING:
11738         case BFILE:
11739         case BLOB:
11740         case CLOB:
11741         case NCLOB:
11742         case YEAR:
11743         case LOCAL:
11744         case WITH:
11745         case ZONE:
11746         case CHARACTER:
11747         case AFTER:
11748         case BEFORE:
11749         case OLD:
11750         case PARENT:
11751         case CC_IF:
11752         case CC_ERROR:
11753         case ANALYZE:
11754         case ASSOCIATE:
11755         case AUDIT:
11756         case COMPOUND:
11757         case DATABASE:
11758         case CALL:
11759         case DDL:
11760         case DISASSOCIATE:
11761         case EACH:
11762         case FOLLOWS:
11763         case LOGOFF:
11764         case LOGON:
11765         case NESTED:
11766         case NOAUDIT:
11767         case SCHEMA:
11768         case SERVERERROR:
11769         case SHUTDOWN:
11770         case STARTUP:
11771         case STATEMENT:
11772         case STATISTICS:
11773         case SUSPEND:
11774         case TRUNCATE:
11775         case WRAPPED:
11776         case LIBRARY:
11777         case NAME:
11778         case STRUCT:
11779         case CONTEXT:
11780         case PARAMETERS:
11781         case LENGTH:
11782         case TDO:
11783         case MAXLEN:
11784         case CHARSETID:
11785         case CHARSETFORM:
11786         case ACCEPT:
11787         case ACCESSIBLE:
11788         case COPY:
11789         case DEFINE:
11790         case DISCONNECT:
11791         case HOST:
11792         case PRINT:
11793         case QUIT:
11794         case REMARK:
11795         case UNDEFINE:
11796         case VARIABLE:
11797         case WHENEVER:
11798         case ATTACH:
11799         case CAST:
11800         case TREAT:
11801         case TRIM:
11802         case LEFT:
11803         case RIGHT:
11804         case BOTH:
11805         case EMPTY:
11806         case MULTISET:
11807         case SUBMULTISET:
11808         case LEADING:
11809         case TRAILING:
11810         case CHAR_CS:
11811         case NCHAR_CS:
11812         case DBTIMEZONE:
11813         case SESSIONTIMEZONE:
11814         case AUTHENTICATED:
11815         case LINK:
11816         case SHARED:
11817         case DIRECTORY:
11818         case USER:
11819         case IDENTIFIER:
11820         case UNSIGNED_NUMERIC_LITERAL:
11821         case CHARACTER_LITERAL:
11822         case STRING_LITERAL:
11823         case QUOTED_LITERAL:
11824           ;
11825           break;
11826         default:
11827           jj_la1[134] = jj_gen;
11828           break label_30;
11829         }
11830       }
11831       jj_consume_token(END);
11832       jj_consume_token(LOOP);
11833       switch (jj_nt.kind) {
11834       case IDENTIFIER:
11835         jj_consume_token(IDENTIFIER);
11836         break;
11837       default:
11838         jj_la1[135] = jj_gen;
11839         ;
11840       }
11841         jjtree.closeNodeScope(jjtn000, true);
11842         jjtc000 = false;
11843         {if (true) return jjtn000 ;}
11844     } catch (Throwable jjte000) {
11845            if (jjtc000) {
11846              jjtree.clearNodeScope(jjtn000);
11847              jjtc000 = false;
11848            } else {
11849              jjtree.popNode();
11850            }
11851            if (jjte000 instanceof RuntimeException) {
11852              {if (true) throw (RuntimeException)jjte000;}
11853            }
11854            if (jjte000 instanceof ParseException) {
11855              {if (true) throw (ParseException)jjte000;}
11856            }
11857            {if (true) throw (Error)jjte000;}
11858     } finally {
11859            if (jjtc000) {
11860              jjtree.closeNodeScope(jjtn000, true);
11861            }
11862     }
11863     throw new Error("Missing return statement in function");
11864   }
11865 
11866   final public ASTWhileStatement WhileStatement() throws ParseException {
11867  /*@bgen(jjtree) WhileStatement */
11868   ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
11869   boolean jjtc000 = true;
11870   jjtree.openNodeScope(jjtn000);
11871     try {
11872       jj_consume_token(WHILE);
11873       Expression();
11874       jj_consume_token(LOOP);
11875       label_31:
11876       while (true) {
11877         Statement();
11878         switch (jj_nt.kind) {
11879         case 5:
11880         case 16:
11881         case 17:
11882         case 21:
11883         case REPLACE:
11884         case DEFINER:
11885         case CURRENT_USER:
11886         case LANGUAGE:
11887         case ADD:
11888         case AGGREGATE:
11889         case ARRAY:
11890         case AT:
11891         case ATTRIBUTE:
11892         case AUTHID:
11893         case BEGIN:
11894         case BODY:
11895         case BULK:
11896         case BYTE:
11897         case CASCADE:
11898         case CASE:
11899         case CLOSE:
11900         case COALESCE:
11901         case COLLECT:
11902         case COLUMN:
11903         case COMMENT:
11904         case COMMIT:
11905         case CONSTRUCTOR:
11906         case CONTINUE:
11907         case CONVERT:
11908         case CURRENT:
11909         case CURSOR:
11910         case DATA:
11911         case DATE:
11912         case DAY:
11913         case DECLARE:
11914         case DELETE:
11915         case DISABLE:
11916         case EDITIONABLE:
11917         case ELEMENT:
11918         case ENABLE:
11919         case ESCAPE:
11920         case EXCEPT:
11921         case EXCEPTIONS:
11922         case EXECUTE:
11923         case EXIT:
11924         case EXTERNAL:
11925         case EXTENDS:
11926         case EXTRACT:
11927         case FALSE:
11928         case FETCH:
11929         case FINAL:
11930         case FOR:
11931         case FORALL:
11932         case FORCE:
11933         case FUNCTION:
11934         case GLOBAL:
11935         case GOTO:
11936         case HASH:
11937         case HEAP:
11938         case HOUR:
11939         case IF:
11940         case IMMEDIATE:
11941         case INDICES:
11942         case INDEXTYPE:
11943         case INDICATOR:
11944         case INSERT:
11945         case INSTANTIABLE:
11946         case INTERVAL:
11947         case INVALIDATE:
11948         case ISOLATION:
11949         case JAVA:
11950         case LEVEL:
11951         case LIMIT:
11952         case LOCK:
11953         case LOOP:
11954         case MAP:
11955         case MAX:
11956         case MEMBER:
11957         case MERGE:
11958         case MIN:
11959         case MINUTE:
11960         case MLSLABEL:
11961         case MODIFY:
11962         case MOD:
11963         case MONTH:
11964         case NATURAL:
11965         case NEW:
11966         case NEW_DOT:
11967         case NO:
11968         case NONEDITIONABLE:
11969         case NOT:
11970         case NULL:
11971         case NULLIF:
11972         case OBJECT:
11973         case OID:
11974         case OPAQUE:
11975         case OPEN:
11976         case OPERATOR:
11977         case ORGANIZATION:
11978         case OTHERS:
11979         case OVERRIDING:
11980         case PACKAGE:
11981         case PARTITION:
11982         case PIPE:
11983         case PRESERVE:
11984         case PRIVATE:
11985         case PROCEDURE:
11986         case RAISE:
11987         case RANGE:
11988         case RAW:
11989         case REAL:
11990         case RECORD:
11991         case REF:
11992         case RELEASE:
11993         case RELIES_ON:
11994         case RENAME:
11995         case RESULT:
11996         case RETURN:
11997         case RETURNING:
11998         case REVERSE:
11999         case ROLLBACK:
12000         case ROW:
12001         case ROWS:
12002         case ROWID:
12003         case ROWNUM:
12004         case SAVE:
12005         case SAVEPOINT:
12006         case SECOND:
12007         case SELECT:
12008         case SELF:
12009         case SET:
12010         case SPACE:
12011         case SQL:
12012         case SQLCODE:
12013         case SQLERRM:
12014         case STATIC:
12015         case SUBTYPE:
12016         case SUBSTITUTABLE:
12017         case SUCCESSFUL:
12018         case SYSDATE:
12019         case SYS_REFCURSOR:
12020         case TEMPORARY:
12021         case TIME:
12022         case TIMESTAMP:
12023         case TIMEZONE_REGION:
12024         case TIMEZONE_ABBR:
12025         case TIMEZONE_MINUTE:
12026         case TIMEZONE_HOUR:
12027         case TRANSACTION:
12028         case TRUE:
12029         case TYPE:
12030         case UNDER:
12031         case USING:
12032         case WHILE:
12033         case YES:
12034         case SHOW:
12035         case A:
12036         case UPDATE:
12037         case DOUBLE:
12038         case DEC:
12039         case PRECISION:
12040         case INT:
12041         case NUMERIC:
12042         case NCHAR:
12043         case NVARCHAR2:
12044         case STRING:
12045         case UROWID:
12046         case VARRAY:
12047         case VARYING:
12048         case BFILE:
12049         case BLOB:
12050         case CLOB:
12051         case NCLOB:
12052         case YEAR:
12053         case LOCAL:
12054         case WITH:
12055         case ZONE:
12056         case CHARACTER:
12057         case AFTER:
12058         case BEFORE:
12059         case OLD:
12060         case PARENT:
12061         case CC_IF:
12062         case CC_ERROR:
12063         case ANALYZE:
12064         case ASSOCIATE:
12065         case AUDIT:
12066         case COMPOUND:
12067         case DATABASE:
12068         case CALL:
12069         case DDL:
12070         case DISASSOCIATE:
12071         case EACH:
12072         case FOLLOWS:
12073         case LOGOFF:
12074         case LOGON:
12075         case NESTED:
12076         case NOAUDIT:
12077         case SCHEMA:
12078         case SERVERERROR:
12079         case SHUTDOWN:
12080         case STARTUP:
12081         case STATEMENT:
12082         case STATISTICS:
12083         case SUSPEND:
12084         case TRUNCATE:
12085         case WRAPPED:
12086         case LIBRARY:
12087         case NAME:
12088         case STRUCT:
12089         case CONTEXT:
12090         case PARAMETERS:
12091         case LENGTH:
12092         case TDO:
12093         case MAXLEN:
12094         case CHARSETID:
12095         case CHARSETFORM:
12096         case ACCEPT:
12097         case ACCESSIBLE:
12098         case COPY:
12099         case DEFINE:
12100         case DISCONNECT:
12101         case HOST:
12102         case PRINT:
12103         case QUIT:
12104         case REMARK:
12105         case UNDEFINE:
12106         case VARIABLE:
12107         case WHENEVER:
12108         case ATTACH:
12109         case CAST:
12110         case TREAT:
12111         case TRIM:
12112         case LEFT:
12113         case RIGHT:
12114         case BOTH:
12115         case EMPTY:
12116         case MULTISET:
12117         case SUBMULTISET:
12118         case LEADING:
12119         case TRAILING:
12120         case CHAR_CS:
12121         case NCHAR_CS:
12122         case DBTIMEZONE:
12123         case SESSIONTIMEZONE:
12124         case AUTHENTICATED:
12125         case LINK:
12126         case SHARED:
12127         case DIRECTORY:
12128         case USER:
12129         case IDENTIFIER:
12130         case UNSIGNED_NUMERIC_LITERAL:
12131         case CHARACTER_LITERAL:
12132         case STRING_LITERAL:
12133         case QUOTED_LITERAL:
12134           ;
12135           break;
12136         default:
12137           jj_la1[136] = jj_gen;
12138           break label_31;
12139         }
12140       }
12141       jj_consume_token(END);
12142       jj_consume_token(LOOP);
12143       switch (jj_nt.kind) {
12144       case IDENTIFIER:
12145         jj_consume_token(IDENTIFIER);
12146         break;
12147       default:
12148         jj_la1[137] = jj_gen;
12149         ;
12150       }
12151         jjtree.closeNodeScope(jjtn000, true);
12152         jjtc000 = false;
12153         {if (true) return jjtn000 ;}
12154     } catch (Throwable jjte000) {
12155            if (jjtc000) {
12156              jjtree.clearNodeScope(jjtn000);
12157              jjtc000 = false;
12158            } else {
12159              jjtree.popNode();
12160            }
12161            if (jjte000 instanceof RuntimeException) {
12162              {if (true) throw (RuntimeException)jjte000;}
12163            }
12164            if (jjte000 instanceof ParseException) {
12165              {if (true) throw (ParseException)jjte000;}
12166            }
12167            {if (true) throw (Error)jjte000;}
12168     } finally {
12169            if (jjtc000) {
12170              jjtree.closeNodeScope(jjtn000, true);
12171            }
12172     }
12173     throw new Error("Missing return statement in function");
12174   }
12175 
12176   final public ASTIfStatement IfStatement() throws ParseException {
12177  /*@bgen(jjtree) IfStatement */
12178   ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
12179   boolean jjtc000 = true;
12180   jjtree.openNodeScope(jjtn000);
12181     try {
12182       jj_consume_token(IF);
12183       Expression();
12184       jj_consume_token(THEN);
12185       label_32:
12186       while (true) {
12187         Statement();
12188         switch (jj_nt.kind) {
12189         case 5:
12190         case 16:
12191         case 17:
12192         case 21:
12193         case REPLACE:
12194         case DEFINER:
12195         case CURRENT_USER:
12196         case LANGUAGE:
12197         case ADD:
12198         case AGGREGATE:
12199         case ARRAY:
12200         case AT:
12201         case ATTRIBUTE:
12202         case AUTHID:
12203         case BEGIN:
12204         case BODY:
12205         case BULK:
12206         case BYTE:
12207         case CASCADE:
12208         case CASE:
12209         case CLOSE:
12210         case COALESCE:
12211         case COLLECT:
12212         case COLUMN:
12213         case COMMENT:
12214         case COMMIT:
12215         case CONSTRUCTOR:
12216         case CONTINUE:
12217         case CONVERT:
12218         case CURRENT:
12219         case CURSOR:
12220         case DATA:
12221         case DATE:
12222         case DAY:
12223         case DECLARE:
12224         case DELETE:
12225         case DISABLE:
12226         case EDITIONABLE:
12227         case ELEMENT:
12228         case ENABLE:
12229         case ESCAPE:
12230         case EXCEPT:
12231         case EXCEPTIONS:
12232         case EXECUTE:
12233         case EXIT:
12234         case EXTERNAL:
12235         case EXTENDS:
12236         case EXTRACT:
12237         case FALSE:
12238         case FETCH:
12239         case FINAL:
12240         case FOR:
12241         case FORALL:
12242         case FORCE:
12243         case FUNCTION:
12244         case GLOBAL:
12245         case GOTO:
12246         case HASH:
12247         case HEAP:
12248         case HOUR:
12249         case IF:
12250         case IMMEDIATE:
12251         case INDICES:
12252         case INDEXTYPE:
12253         case INDICATOR:
12254         case INSERT:
12255         case INSTANTIABLE:
12256         case INTERVAL:
12257         case INVALIDATE:
12258         case ISOLATION:
12259         case JAVA:
12260         case LEVEL:
12261         case LIMIT:
12262         case LOCK:
12263         case LOOP:
12264         case MAP:
12265         case MAX:
12266         case MEMBER:
12267         case MERGE:
12268         case MIN:
12269         case MINUTE:
12270         case MLSLABEL:
12271         case MODIFY:
12272         case MOD:
12273         case MONTH:
12274         case NATURAL:
12275         case NEW:
12276         case NEW_DOT:
12277         case NO:
12278         case NONEDITIONABLE:
12279         case NOT:
12280         case NULL:
12281         case NULLIF:
12282         case OBJECT:
12283         case OID:
12284         case OPAQUE:
12285         case OPEN:
12286         case OPERATOR:
12287         case ORGANIZATION:
12288         case OTHERS:
12289         case OVERRIDING:
12290         case PACKAGE:
12291         case PARTITION:
12292         case PIPE:
12293         case PRESERVE:
12294         case PRIVATE:
12295         case PROCEDURE:
12296         case RAISE:
12297         case RANGE:
12298         case RAW:
12299         case REAL:
12300         case RECORD:
12301         case REF:
12302         case RELEASE:
12303         case RELIES_ON:
12304         case RENAME:
12305         case RESULT:
12306         case RETURN:
12307         case RETURNING:
12308         case REVERSE:
12309         case ROLLBACK:
12310         case ROW:
12311         case ROWS:
12312         case ROWID:
12313         case ROWNUM:
12314         case SAVE:
12315         case SAVEPOINT:
12316         case SECOND:
12317         case SELECT:
12318         case SELF:
12319         case SET:
12320         case SPACE:
12321         case SQL:
12322         case SQLCODE:
12323         case SQLERRM:
12324         case STATIC:
12325         case SUBTYPE:
12326         case SUBSTITUTABLE:
12327         case SUCCESSFUL:
12328         case SYSDATE:
12329         case SYS_REFCURSOR:
12330         case TEMPORARY:
12331         case TIME:
12332         case TIMESTAMP:
12333         case TIMEZONE_REGION:
12334         case TIMEZONE_ABBR:
12335         case TIMEZONE_MINUTE:
12336         case TIMEZONE_HOUR:
12337         case TRANSACTION:
12338         case TRUE:
12339         case TYPE:
12340         case UNDER:
12341         case USING:
12342         case WHILE:
12343         case YES:
12344         case SHOW:
12345         case A:
12346         case UPDATE:
12347         case DOUBLE:
12348         case DEC:
12349         case PRECISION:
12350         case INT:
12351         case NUMERIC:
12352         case NCHAR:
12353         case NVARCHAR2:
12354         case STRING:
12355         case UROWID:
12356         case VARRAY:
12357         case VARYING:
12358         case BFILE:
12359         case BLOB:
12360         case CLOB:
12361         case NCLOB:
12362         case YEAR:
12363         case LOCAL:
12364         case WITH:
12365         case ZONE:
12366         case CHARACTER:
12367         case AFTER:
12368         case BEFORE:
12369         case OLD:
12370         case PARENT:
12371         case CC_IF:
12372         case CC_ERROR:
12373         case ANALYZE:
12374         case ASSOCIATE:
12375         case AUDIT:
12376         case COMPOUND:
12377         case DATABASE:
12378         case CALL:
12379         case DDL:
12380         case DISASSOCIATE:
12381         case EACH:
12382         case FOLLOWS:
12383         case LOGOFF:
12384         case LOGON:
12385         case NESTED:
12386         case NOAUDIT:
12387         case SCHEMA:
12388         case SERVERERROR:
12389         case SHUTDOWN:
12390         case STARTUP:
12391         case STATEMENT:
12392         case STATISTICS:
12393         case SUSPEND:
12394         case TRUNCATE:
12395         case WRAPPED:
12396         case LIBRARY:
12397         case NAME:
12398         case STRUCT:
12399         case CONTEXT:
12400         case PARAMETERS:
12401         case LENGTH:
12402         case TDO:
12403         case MAXLEN:
12404         case CHARSETID:
12405         case CHARSETFORM:
12406         case ACCEPT:
12407         case ACCESSIBLE:
12408         case COPY:
12409         case DEFINE:
12410         case DISCONNECT:
12411         case HOST:
12412         case PRINT:
12413         case QUIT:
12414         case REMARK:
12415         case UNDEFINE:
12416         case VARIABLE:
12417         case WHENEVER:
12418         case ATTACH:
12419         case CAST:
12420         case TREAT:
12421         case TRIM:
12422         case LEFT:
12423         case RIGHT:
12424         case BOTH:
12425         case EMPTY:
12426         case MULTISET:
12427         case SUBMULTISET:
12428         case LEADING:
12429         case TRAILING:
12430         case CHAR_CS:
12431         case NCHAR_CS:
12432         case DBTIMEZONE:
12433         case SESSIONTIMEZONE:
12434         case AUTHENTICATED:
12435         case LINK:
12436         case SHARED:
12437         case DIRECTORY:
12438         case USER:
12439         case IDENTIFIER:
12440         case UNSIGNED_NUMERIC_LITERAL:
12441         case CHARACTER_LITERAL:
12442         case STRING_LITERAL:
12443         case QUOTED_LITERAL:
12444           ;
12445           break;
12446         default:
12447           jj_la1[138] = jj_gen;
12448           break label_32;
12449         }
12450       }
12451       label_33:
12452       while (true) {
12453         switch (jj_nt.kind) {
12454         case ELSIF:
12455           ;
12456           break;
12457         default:
12458           jj_la1[139] = jj_gen;
12459           break label_33;
12460         }
12461         ElsifClause();
12462                          jjtn000.setHasElse();
12463       }
12464       switch (jj_nt.kind) {
12465       case ELSE:
12466         ElseClause();
12467                         jjtn000.setHasElse();
12468         break;
12469       default:
12470         jj_la1[140] = jj_gen;
12471         ;
12472       }
12473       jj_consume_token(END);
12474       jj_consume_token(IF);
12475         jjtree.closeNodeScope(jjtn000, true);
12476         jjtc000 = false;
12477         {if (true) return jjtn000 ;}
12478     } catch (Throwable jjte000) {
12479           if (jjtc000) {
12480             jjtree.clearNodeScope(jjtn000);
12481             jjtc000 = false;
12482           } else {
12483             jjtree.popNode();
12484           }
12485           if (jjte000 instanceof RuntimeException) {
12486             {if (true) throw (RuntimeException)jjte000;}
12487           }
12488           if (jjte000 instanceof ParseException) {
12489             {if (true) throw (ParseException)jjte000;}
12490           }
12491           {if (true) throw (Error)jjte000;}
12492     } finally {
12493           if (jjtc000) {
12494             jjtree.closeNodeScope(jjtn000, true);
12495           }
12496     }
12497     throw new Error("Missing return statement in function");
12498   }
12499 
12500 /** Scope rule: the loop index only exists within the statement */
12501 /**
12502 ForIndex is declared implicitly, unlike most variables or constants.
12503 */
12504   final public ASTForIndex ForIndex() throws ParseException {
12505  /*@bgen(jjtree) ForIndex */
12506  ASTForIndex jjtn000 = new ASTForIndex(this, JJTFORINDEX);
12507  boolean jjtc000 = true;
12508  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
12509     try {
12510       simpleNode = ID();
12511    jjtree.closeNodeScope(jjtn000, true);
12512    jjtc000 = false;
12513    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
12514     } catch (Throwable jjte000) {
12515    if (jjtc000) {
12516      jjtree.clearNodeScope(jjtn000);
12517      jjtc000 = false;
12518    } else {
12519      jjtree.popNode();
12520    }
12521    if (jjte000 instanceof RuntimeException) {
12522      {if (true) throw (RuntimeException)jjte000;}
12523    }
12524    if (jjte000 instanceof ParseException) {
12525      {if (true) throw (ParseException)jjte000;}
12526    }
12527    {if (true) throw (Error)jjte000;}
12528     } finally {
12529    if (jjtc000) {
12530      jjtree.closeNodeScope(jjtn000, true);
12531    }
12532     }
12533     throw new Error("Missing return statement in function");
12534   }
12535 
12536 /**
12537 ForAllIndex is declared implicitly, unlike most variables or constants.
12538 */
12539   final public ASTForAllIndex ForAllIndex() throws ParseException {
12540  /*@bgen(jjtree) ForAllIndex */
12541  ASTForAllIndex jjtn000 = new ASTForAllIndex(this, JJTFORALLINDEX);
12542  boolean jjtc000 = true;
12543  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
12544     try {
12545       simpleNode = ID();
12546    jjtree.closeNodeScope(jjtn000, true);
12547    jjtc000 = false;
12548    jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
12549     } catch (Throwable jjte000) {
12550    if (jjtc000) {
12551      jjtree.clearNodeScope(jjtn000);
12552      jjtc000 = false;
12553    } else {
12554      jjtree.popNode();
12555    }
12556    if (jjte000 instanceof RuntimeException) {
12557      {if (true) throw (RuntimeException)jjte000;}
12558    }
12559    if (jjte000 instanceof ParseException) {
12560      {if (true) throw (ParseException)jjte000;}
12561    }
12562    {if (true) throw (Error)jjte000;}
12563     } finally {
12564    if (jjtc000) {
12565      jjtree.closeNodeScope(jjtn000, true);
12566    }
12567     }
12568     throw new Error("Missing return statement in function");
12569   }
12570 
12571   final public ASTForAllStatement ForAllStatement() throws ParseException {
12572  /*@bgen(jjtree) ForAllStatement */
12573   ASTForAllStatement jjtn000 = new ASTForAllStatement(this, JJTFORALLSTATEMENT);
12574   boolean jjtc000 = true;
12575   jjtree.openNodeScope(jjtn000);
12576     try {
12577       jj_consume_token(FORALL);
12578       ForAllIndex();
12579       jj_consume_token(IN);
12580       switch (jj_nt.kind) {
12581       case INDICES:
12582       case VALUES:
12583         switch (jj_nt.kind) {
12584         case INDICES:
12585           jj_consume_token(INDICES);
12586           break;
12587         case VALUES:
12588           jj_consume_token(VALUES);
12589           break;
12590         default:
12591           jj_la1[141] = jj_gen;
12592           jj_consume_token(-1);
12593           throw new ParseException();
12594         }
12595         jj_consume_token(OF);
12596         Expression();
12597         break;
12598       case 5:
12599       case 16:
12600       case 17:
12601       case REPLACE:
12602       case DEFINER:
12603       case CURRENT_USER:
12604       case LANGUAGE:
12605       case ADD:
12606       case AGGREGATE:
12607       case ARRAY:
12608       case AT:
12609       case ATTRIBUTE:
12610       case AUTHID:
12611       case BODY:
12612       case BULK:
12613       case BYTE:
12614       case CASCADE:
12615       case CASE:
12616       case CLOSE:
12617       case COALESCE:
12618       case COLLECT:
12619       case COLUMN:
12620       case COMMENT:
12621       case COMMIT:
12622       case CONSTRUCTOR:
12623       case CONTINUE:
12624       case CONVERT:
12625       case CURRENT:
12626       case CURSOR:
12627       case DATA:
12628       case DATE:
12629       case DAY:
12630       case DISABLE:
12631       case EDITIONABLE:
12632       case ELEMENT:
12633       case ENABLE:
12634       case ESCAPE:
12635       case EXCEPT:
12636       case EXCEPTIONS:
12637       case EXIT:
12638       case EXTERNAL:
12639       case EXTENDS:
12640       case EXTRACT:
12641       case FALSE:
12642       case FINAL:
12643       case FORCE:
12644       case FUNCTION:
12645       case GLOBAL:
12646       case HASH:
12647       case HEAP:
12648       case HOUR:
12649       case IMMEDIATE:
12650       case INDEXTYPE:
12651       case INDICATOR:
12652       case INSTANTIABLE:
12653       case INTERVAL:
12654       case INVALIDATE:
12655       case ISOLATION:
12656       case JAVA:
12657       case LEVEL:
12658       case LIMIT:
12659       case LOOP:
12660       case MAP:
12661       case MAX:
12662       case MEMBER:
12663       case MERGE:
12664       case MIN:
12665       case MINUTE:
12666       case MLSLABEL:
12667       case MODIFY:
12668       case MOD:
12669       case MONTH:
12670       case NATURAL:
12671       case NEW:
12672       case NEW_DOT:
12673       case NO:
12674       case NONEDITIONABLE:
12675       case NOT:
12676       case NULL:
12677       case NULLIF:
12678       case OBJECT:
12679       case OID:
12680       case OPAQUE:
12681       case OPEN:
12682       case OPERATOR:
12683       case ORGANIZATION:
12684       case OTHERS:
12685       case OVERRIDING:
12686       case PACKAGE:
12687       case PARTITION:
12688       case PRESERVE:
12689       case PRIVATE:
12690       case PROCEDURE:
12691       case RANGE:
12692       case RAW:
12693       case REAL:
12694       case RECORD:
12695       case REF:
12696       case RELEASE:
12697       case RELIES_ON:
12698       case RENAME:
12699       case RESULT:
12700       case RETURN:
12701       case RETURNING:
12702       case REVERSE:
12703       case ROLLBACK:
12704       case ROW:
12705       case ROWS:
12706       case ROWID:
12707       case ROWNUM:
12708       case SAVE:
12709       case SAVEPOINT:
12710       case SECOND:
12711       case SELECT:
12712       case SELF:
12713       case SET:
12714       case SPACE:
12715       case SQL:
12716       case SQLCODE:
12717       case SQLERRM:
12718       case STATIC:
12719       case SUBTYPE:
12720       case SUBSTITUTABLE:
12721       case SUCCESSFUL:
12722       case SYSDATE:
12723       case SYS_REFCURSOR:
12724       case TEMPORARY:
12725       case TIME:
12726       case TIMESTAMP:
12727       case TIMEZONE_REGION:
12728       case TIMEZONE_ABBR:
12729       case TIMEZONE_MINUTE:
12730       case TIMEZONE_HOUR:
12731       case TRANSACTION:
12732       case TRUE:
12733       case TYPE:
12734       case UNDER:
12735       case USING:
12736       case YES:
12737       case SHOW:
12738       case A:
12739       case DOUBLE:
12740       case DEC:
12741       case PRECISION:
12742       case INT:
12743       case NUMERIC:
12744       case NCHAR:
12745       case NVARCHAR2:
12746       case STRING:
12747       case UROWID:
12748       case VARRAY:
12749       case VARYING:
12750       case BFILE:
12751       case BLOB:
12752       case CLOB:
12753       case NCLOB:
12754       case YEAR:
12755       case LOCAL:
12756       case WITH:
12757       case ZONE:
12758       case CHARACTER:
12759       case AFTER:
12760       case BEFORE:
12761       case OLD:
12762       case PARENT:
12763       case CC_IF:
12764       case ANALYZE:
12765       case ASSOCIATE:
12766       case AUDIT:
12767       case COMPOUND:
12768       case DATABASE:
12769       case CALL:
12770       case DDL:
12771       case DISASSOCIATE:
12772       case EACH:
12773       case FOLLOWS:
12774       case LOGOFF:
12775       case LOGON:
12776       case NESTED:
12777       case NOAUDIT:
12778       case SCHEMA:
12779       case SERVERERROR:
12780       case SHUTDOWN:
12781       case STARTUP:
12782       case STATEMENT:
12783       case STATISTICS:
12784       case SUSPEND:
12785       case TRUNCATE:
12786       case WRAPPED:
12787       case LIBRARY:
12788       case NAME:
12789       case STRUCT:
12790       case CONTEXT:
12791       case PARAMETERS:
12792       case LENGTH:
12793       case TDO:
12794       case MAXLEN:
12795       case CHARSETID:
12796       case CHARSETFORM:
12797       case ACCEPT:
12798       case ACCESSIBLE:
12799       case COPY:
12800       case DEFINE:
12801       case DISCONNECT:
12802       case HOST:
12803       case PRINT:
12804       case QUIT:
12805       case REMARK:
12806       case UNDEFINE:
12807       case VARIABLE:
12808       case WHENEVER:
12809       case ATTACH:
12810       case CAST:
12811       case TREAT:
12812       case TRIM:
12813       case LEFT:
12814       case RIGHT:
12815       case BOTH:
12816       case EMPTY:
12817       case MULTISET:
12818       case SUBMULTISET:
12819       case LEADING:
12820       case TRAILING:
12821       case CHAR_CS:
12822       case NCHAR_CS:
12823       case DBTIMEZONE:
12824       case SESSIONTIMEZONE:
12825       case AUTHENTICATED:
12826       case LINK:
12827       case SHARED:
12828       case DIRECTORY:
12829       case USER:
12830       case IDENTIFIER:
12831       case UNSIGNED_NUMERIC_LITERAL:
12832       case CHARACTER_LITERAL:
12833       case STRING_LITERAL:
12834       case QUOTED_LITERAL:
12835         Expression();
12836         switch (jj_nt.kind) {
12837         case 12:
12838           jj_consume_token(12);
12839           Expression();
12840           break;
12841         default:
12842           jj_la1[142] = jj_gen;
12843           ;
12844         }
12845         break;
12846       default:
12847         jj_la1[143] = jj_gen;
12848         jj_consume_token(-1);
12849         throw new ParseException();
12850       }
12851       switch (jj_nt.kind) {
12852       case SAVE:
12853         jj_consume_token(SAVE);
12854         jj_consume_token(EXCEPTIONS);
12855         break;
12856       default:
12857         jj_la1[144] = jj_gen;
12858         ;
12859       }
12860       SqlStatement(null,";");
12861         jjtree.closeNodeScope(jjtn000, true);
12862         jjtc000 = false;
12863         {if (true) return jjtn000 ;}
12864     } catch (Throwable jjte000) {
12865            if (jjtc000) {
12866              jjtree.clearNodeScope(jjtn000);
12867              jjtc000 = false;
12868            } else {
12869              jjtree.popNode();
12870            }
12871            if (jjte000 instanceof RuntimeException) {
12872              {if (true) throw (RuntimeException)jjte000;}
12873            }
12874            if (jjte000 instanceof ParseException) {
12875              {if (true) throw (ParseException)jjte000;}
12876            }
12877            {if (true) throw (Error)jjte000;}
12878     } finally {
12879            if (jjtc000) {
12880              jjtree.closeNodeScope(jjtn000, true);
12881            }
12882     }
12883     throw new Error("Missing return statement in function");
12884   }
12885 
12886   final public ASTGotoStatement GotoStatement() throws ParseException {
12887  /*@bgen(jjtree) GotoStatement */
12888  ASTGotoStatement jjtn000 = new ASTGotoStatement(this, JJTGOTOSTATEMENT);
12889  boolean jjtc000 = true;
12890  jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
12891     try {
12892       jj_consume_token(GOTO);
12893       label = QualifiedName();
12894         jjtree.closeNodeScope(jjtn000, true);
12895         jjtc000 = false;
12896         jjtn000.setImage(label.getImage()) ; {if (true) return jjtn000 ;}
12897     } catch (Throwable jjte000) {
12898           if (jjtc000) {
12899             jjtree.clearNodeScope(jjtn000);
12900             jjtc000 = false;
12901           } else {
12902             jjtree.popNode();
12903           }
12904           if (jjte000 instanceof RuntimeException) {
12905             {if (true) throw (RuntimeException)jjte000;}
12906           }
12907           if (jjte000 instanceof ParseException) {
12908             {if (true) throw (ParseException)jjte000;}
12909           }
12910           {if (true) throw (Error)jjte000;}
12911     } finally {
12912           if (jjtc000) {
12913             jjtree.closeNodeScope(jjtn000, true);
12914           }
12915     }
12916     throw new Error("Missing return statement in function");
12917   }
12918 
12919   final public ASTReturnStatement ReturnStatement() throws ParseException {
12920  /*@bgen(jjtree) ReturnStatement */
12921   ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT);
12922   boolean jjtc000 = true;
12923   jjtree.openNodeScope(jjtn000);
12924     try {
12925       jj_consume_token(RETURN);
12926       switch (jj_nt.kind) {
12927       case 5:
12928       case 16:
12929       case 17:
12930       case REPLACE:
12931       case DEFINER:
12932       case CURRENT_USER:
12933       case LANGUAGE:
12934       case ADD:
12935       case AGGREGATE:
12936       case ARRAY:
12937       case AT:
12938       case ATTRIBUTE:
12939       case AUTHID:
12940       case BODY:
12941       case BULK:
12942       case BYTE:
12943       case CASCADE:
12944       case CASE:
12945       case CLOSE:
12946       case COALESCE:
12947       case COLLECT:
12948       case COLUMN:
12949       case COMMENT:
12950       case COMMIT:
12951       case CONSTRUCTOR:
12952       case CONTINUE:
12953       case CONVERT:
12954       case CURRENT:
12955       case CURSOR:
12956       case DATA:
12957       case DATE:
12958       case DAY:
12959       case DISABLE:
12960       case EDITIONABLE:
12961       case ELEMENT:
12962       case ENABLE:
12963       case ESCAPE:
12964       case EXCEPT:
12965       case EXCEPTIONS:
12966       case EXIT:
12967       case EXTERNAL:
12968       case EXTENDS:
12969       case EXTRACT:
12970       case FALSE:
12971       case FINAL:
12972       case FORCE:
12973       case FUNCTION:
12974       case GLOBAL:
12975       case HASH:
12976       case HEAP:
12977       case HOUR:
12978       case IMMEDIATE:
12979       case INDICES:
12980       case INDEXTYPE:
12981       case INDICATOR:
12982       case INSTANTIABLE:
12983       case INTERVAL:
12984       case INVALIDATE:
12985       case ISOLATION:
12986       case JAVA:
12987       case LEVEL:
12988       case LIMIT:
12989       case LOOP:
12990       case MAP:
12991       case MAX:
12992       case MEMBER:
12993       case MERGE:
12994       case MIN:
12995       case MINUTE:
12996       case MLSLABEL:
12997       case MODIFY:
12998       case MOD:
12999       case MONTH:
13000       case NATURAL:
13001       case NEW:
13002       case NEW_DOT:
13003       case NO:
13004       case NONEDITIONABLE:
13005       case NOT:
13006       case NULL:
13007       case NULLIF:
13008       case OBJECT:
13009       case OID:
13010       case OPAQUE:
13011       case OPEN:
13012       case OPERATOR:
13013       case ORGANIZATION:
13014       case OTHERS:
13015       case OVERRIDING:
13016       case PACKAGE:
13017       case PARTITION:
13018       case PRESERVE:
13019       case PRIVATE:
13020       case PROCEDURE:
13021       case RANGE:
13022       case RAW:
13023       case REAL:
13024       case RECORD:
13025       case REF:
13026       case RELEASE:
13027       case RELIES_ON:
13028       case RENAME:
13029       case RESULT:
13030       case RETURN:
13031       case RETURNING:
13032       case REVERSE:
13033       case ROLLBACK:
13034       case ROW:
13035       case ROWS:
13036       case ROWID:
13037       case ROWNUM:
13038       case SAVE:
13039       case SAVEPOINT:
13040       case SECOND:
13041       case SELECT:
13042       case SELF:
13043       case SET:
13044       case SPACE:
13045       case SQL:
13046       case SQLCODE:
13047       case SQLERRM:
13048       case STATIC:
13049       case SUBTYPE:
13050       case SUBSTITUTABLE:
13051       case SUCCESSFUL:
13052       case SYSDATE:
13053       case SYS_REFCURSOR:
13054       case TEMPORARY:
13055       case TIME:
13056       case TIMESTAMP:
13057       case TIMEZONE_REGION:
13058       case TIMEZONE_ABBR:
13059       case TIMEZONE_MINUTE:
13060       case TIMEZONE_HOUR:
13061       case TRANSACTION:
13062       case TRUE:
13063       case TYPE:
13064       case UNDER:
13065       case USING:
13066       case YES:
13067       case SHOW:
13068       case A:
13069       case DOUBLE:
13070       case DEC:
13071       case PRECISION:
13072       case INT:
13073       case NUMERIC:
13074       case NCHAR:
13075       case NVARCHAR2:
13076       case STRING:
13077       case UROWID:
13078       case VARRAY:
13079       case VARYING:
13080       case BFILE:
13081       case BLOB:
13082       case CLOB:
13083       case NCLOB:
13084       case YEAR:
13085       case LOCAL:
13086       case WITH:
13087       case ZONE:
13088       case CHARACTER:
13089       case AFTER:
13090       case BEFORE:
13091       case OLD:
13092       case PARENT:
13093       case CC_IF:
13094       case ANALYZE:
13095       case ASSOCIATE:
13096       case AUDIT:
13097       case COMPOUND:
13098       case DATABASE:
13099       case CALL:
13100       case DDL:
13101       case DISASSOCIATE:
13102       case EACH:
13103       case FOLLOWS:
13104       case LOGOFF:
13105       case LOGON:
13106       case NESTED:
13107       case NOAUDIT:
13108       case SCHEMA:
13109       case SERVERERROR:
13110       case SHUTDOWN:
13111       case STARTUP:
13112       case STATEMENT:
13113       case STATISTICS:
13114       case SUSPEND:
13115       case TRUNCATE:
13116       case WRAPPED:
13117       case LIBRARY:
13118       case NAME:
13119       case STRUCT:
13120       case CONTEXT:
13121       case PARAMETERS:
13122       case LENGTH:
13123       case TDO:
13124       case MAXLEN:
13125       case CHARSETID:
13126       case CHARSETFORM:
13127       case ACCEPT:
13128       case ACCESSIBLE:
13129       case COPY:
13130       case DEFINE:
13131       case DISCONNECT:
13132       case HOST:
13133       case PRINT:
13134       case QUIT:
13135       case REMARK:
13136       case UNDEFINE:
13137       case VARIABLE:
13138       case WHENEVER:
13139       case ATTACH:
13140       case CAST:
13141       case TREAT:
13142       case TRIM:
13143       case LEFT:
13144       case RIGHT:
13145       case BOTH:
13146       case EMPTY:
13147       case MULTISET:
13148       case SUBMULTISET:
13149       case LEADING:
13150       case TRAILING:
13151       case CHAR_CS:
13152       case NCHAR_CS:
13153       case DBTIMEZONE:
13154       case SESSIONTIMEZONE:
13155       case AUTHENTICATED:
13156       case LINK:
13157       case SHARED:
13158       case DIRECTORY:
13159       case USER:
13160       case IDENTIFIER:
13161       case UNSIGNED_NUMERIC_LITERAL:
13162       case CHARACTER_LITERAL:
13163       case STRING_LITERAL:
13164       case QUOTED_LITERAL:
13165         Expression();
13166         break;
13167       default:
13168         jj_la1[145] = jj_gen;
13169         ;
13170       }
13171         jjtree.closeNodeScope(jjtn000, true);
13172         jjtc000 = false;
13173         {if (true) return jjtn000 ;}
13174     } catch (Throwable jjte000) {
13175           if (jjtc000) {
13176             jjtree.clearNodeScope(jjtn000);
13177             jjtc000 = false;
13178           } else {
13179             jjtree.popNode();
13180           }
13181           if (jjte000 instanceof RuntimeException) {
13182             {if (true) throw (RuntimeException)jjte000;}
13183           }
13184           if (jjte000 instanceof ParseException) {
13185             {if (true) throw (ParseException)jjte000;}
13186           }
13187           {if (true) throw (Error)jjte000;}
13188     } finally {
13189           if (jjtc000) {
13190             jjtree.closeNodeScope(jjtn000, true);
13191           }
13192     }
13193     throw new Error("Missing return statement in function");
13194   }
13195 
13196   final public ASTContinueStatement ContinueStatement() throws ParseException {
13197  /*@bgen(jjtree) ContinueStatement */
13198  ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT);
13199  boolean jjtc000 = true;
13200  jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
13201     try {
13202       jj_consume_token(CONTINUE);
13203       switch (jj_nt.kind) {
13204       case REPLACE:
13205       case DEFINER:
13206       case CURRENT_USER:
13207       case LANGUAGE:
13208       case ADD:
13209       case AGGREGATE:
13210       case ARRAY:
13211       case AT:
13212       case ATTRIBUTE:
13213       case AUTHID:
13214       case BODY:
13215       case BULK:
13216       case BYTE:
13217       case CASCADE:
13218       case CLOSE:
13219       case COALESCE:
13220       case COLLECT:
13221       case COLUMN:
13222       case COMMENT:
13223       case COMMIT:
13224       case CONSTRUCTOR:
13225       case CONTINUE:
13226       case CONVERT:
13227       case CURRENT:
13228       case CURSOR:
13229       case DATA:
13230       case DAY:
13231       case DISABLE:
13232       case EDITIONABLE:
13233       case ELEMENT:
13234       case ENABLE:
13235       case ESCAPE:
13236       case EXCEPT:
13237       case EXCEPTIONS:
13238       case EXIT:
13239       case EXTERNAL:
13240       case EXTENDS:
13241       case EXTRACT:
13242       case FALSE:
13243       case FINAL:
13244       case FORCE:
13245       case FUNCTION:
13246       case GLOBAL:
13247       case HASH:
13248       case HEAP:
13249       case HOUR:
13250       case IMMEDIATE:
13251       case INDICES:
13252       case INDEXTYPE:
13253       case INDICATOR:
13254       case INSTANTIABLE:
13255       case INTERVAL:
13256       case INVALIDATE:
13257       case ISOLATION:
13258       case JAVA:
13259       case LEVEL:
13260       case LIMIT:
13261       case LOOP:
13262       case MAP:
13263       case MAX:
13264       case MEMBER:
13265       case MERGE:
13266       case MIN:
13267       case MINUTE:
13268       case MLSLABEL:
13269       case MODIFY:
13270       case MOD:
13271       case MONTH:
13272       case NATURAL:
13273       case NEW:
13274       case NO:
13275       case NONEDITIONABLE:
13276       case NULLIF:
13277       case OBJECT:
13278       case OID:
13279       case OPAQUE:
13280       case OPEN:
13281       case OPERATOR:
13282       case ORGANIZATION:
13283       case OTHERS:
13284       case OVERRIDING:
13285       case PACKAGE:
13286       case PARTITION:
13287       case PRESERVE:
13288       case PRIVATE:
13289       case PROCEDURE:
13290       case RANGE:
13291       case RAW:
13292       case REAL:
13293       case RECORD:
13294       case REF:
13295       case RELEASE:
13296       case RELIES_ON:
13297       case RENAME:
13298       case RESULT:
13299       case RETURN:
13300       case RETURNING:
13301       case REVERSE:
13302       case ROLLBACK:
13303       case ROW:
13304       case ROWS:
13305       case ROWID:
13306       case ROWNUM:
13307       case SAVE:
13308       case SAVEPOINT:
13309       case SECOND:
13310       case SELF:
13311       case SET:
13312       case SPACE:
13313       case SQL:
13314       case SQLCODE:
13315       case SQLERRM:
13316       case STATIC:
13317       case SUBTYPE:
13318       case SUBSTITUTABLE:
13319       case SUCCESSFUL:
13320       case SYSDATE:
13321       case SYS_REFCURSOR:
13322       case TEMPORARY:
13323       case TIME:
13324       case TIMESTAMP:
13325       case TIMEZONE_REGION:
13326       case TIMEZONE_ABBR:
13327       case TIMEZONE_MINUTE:
13328       case TIMEZONE_HOUR:
13329       case TRANSACTION:
13330       case TRUE:
13331       case TYPE:
13332       case UNDER:
13333       case USING:
13334       case YES:
13335       case SHOW:
13336       case A:
13337       case DOUBLE:
13338       case DEC:
13339       case PRECISION:
13340       case INT:
13341       case NUMERIC:
13342       case NCHAR:
13343       case NVARCHAR2:
13344       case STRING:
13345       case UROWID:
13346       case VARRAY:
13347       case VARYING:
13348       case BFILE:
13349       case BLOB:
13350       case CLOB:
13351       case NCLOB:
13352       case YEAR:
13353       case LOCAL:
13354       case ZONE:
13355       case CHARACTER:
13356       case AFTER:
13357       case BEFORE:
13358       case OLD:
13359       case PARENT:
13360       case ANALYZE:
13361       case ASSOCIATE:
13362       case AUDIT:
13363       case COMPOUND:
13364       case DATABASE:
13365       case CALL:
13366       case DDL:
13367       case DISASSOCIATE:
13368       case EACH:
13369       case FOLLOWS:
13370       case LOGOFF:
13371       case LOGON:
13372       case NESTED:
13373       case NOAUDIT:
13374       case SCHEMA:
13375       case SERVERERROR:
13376       case SHUTDOWN:
13377       case STARTUP:
13378       case STATEMENT:
13379       case STATISTICS:
13380       case SUSPEND:
13381       case TRUNCATE:
13382       case WRAPPED:
13383       case LIBRARY:
13384       case NAME:
13385       case STRUCT:
13386       case CONTEXT:
13387       case PARAMETERS:
13388       case LENGTH:
13389       case TDO:
13390       case MAXLEN:
13391       case CHARSETID:
13392       case CHARSETFORM:
13393       case ACCEPT:
13394       case ACCESSIBLE:
13395       case COPY:
13396       case DEFINE:
13397       case DISCONNECT:
13398       case HOST:
13399       case PRINT:
13400       case QUIT:
13401       case REMARK:
13402       case UNDEFINE:
13403       case VARIABLE:
13404       case WHENEVER:
13405       case ATTACH:
13406       case CAST:
13407       case TREAT:
13408       case TRIM:
13409       case LEFT:
13410       case RIGHT:
13411       case BOTH:
13412       case EMPTY:
13413       case MULTISET:
13414       case SUBMULTISET:
13415       case LEADING:
13416       case TRAILING:
13417       case CHAR_CS:
13418       case NCHAR_CS:
13419       case DBTIMEZONE:
13420       case SESSIONTIMEZONE:
13421       case AUTHENTICATED:
13422       case LINK:
13423       case SHARED:
13424       case DIRECTORY:
13425       case USER:
13426       case IDENTIFIER:
13427       case QUOTED_LITERAL:
13428         label = UnqualifiedID();
13429         break;
13430       default:
13431         jj_la1[146] = jj_gen;
13432         ;
13433       }
13434       switch (jj_nt.kind) {
13435       case WHEN:
13436         jj_consume_token(WHEN);
13437         Expression();
13438         break;
13439       default:
13440         jj_la1[147] = jj_gen;
13441         ;
13442       }
13443         jjtree.closeNodeScope(jjtn000, true);
13444         jjtc000 = false;
13445         if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
13446     } catch (Throwable jjte000) {
13447           if (jjtc000) {
13448             jjtree.clearNodeScope(jjtn000);
13449             jjtc000 = false;
13450           } else {
13451             jjtree.popNode();
13452           }
13453           if (jjte000 instanceof RuntimeException) {
13454             {if (true) throw (RuntimeException)jjte000;}
13455           }
13456           if (jjte000 instanceof ParseException) {
13457             {if (true) throw (ParseException)jjte000;}
13458           }
13459           {if (true) throw (Error)jjte000;}
13460     } finally {
13461           if (jjtc000) {
13462             jjtree.closeNodeScope(jjtn000, true);
13463           }
13464     }
13465     throw new Error("Missing return statement in function");
13466   }
13467 
13468   final public ASTExitStatement ExitStatement() throws ParseException {
13469  /*@bgen(jjtree) ExitStatement */
13470  ASTExitStatement jjtn000 = new ASTExitStatement(this, JJTEXITSTATEMENT);
13471  boolean jjtc000 = true;
13472  jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
13473     try {
13474       jj_consume_token(EXIT);
13475       switch (jj_nt.kind) {
13476       case REPLACE:
13477       case DEFINER:
13478       case CURRENT_USER:
13479       case LANGUAGE:
13480       case ADD:
13481       case AGGREGATE:
13482       case ARRAY:
13483       case AT:
13484       case ATTRIBUTE:
13485       case AUTHID:
13486       case BODY:
13487       case BULK:
13488       case BYTE:
13489       case CASCADE:
13490       case CLOSE:
13491       case COALESCE:
13492       case COLLECT:
13493       case COLUMN:
13494       case COMMENT:
13495       case COMMIT:
13496       case CONSTRUCTOR:
13497       case CONTINUE:
13498       case CONVERT:
13499       case CURRENT:
13500       case CURSOR:
13501       case DATA:
13502       case DAY:
13503       case DISABLE:
13504       case EDITIONABLE:
13505       case ELEMENT:
13506       case ENABLE:
13507       case ESCAPE:
13508       case EXCEPT:
13509       case EXCEPTIONS:
13510       case EXIT:
13511       case EXTERNAL:
13512       case EXTENDS:
13513       case EXTRACT:
13514       case FALSE:
13515       case FINAL:
13516       case FORCE:
13517       case FUNCTION:
13518       case GLOBAL:
13519       case HASH:
13520       case HEAP:
13521       case HOUR:
13522       case IMMEDIATE:
13523       case INDICES:
13524       case INDEXTYPE:
13525       case INDICATOR:
13526       case INSTANTIABLE:
13527       case INTERVAL:
13528       case INVALIDATE:
13529       case ISOLATION:
13530       case JAVA:
13531       case LEVEL:
13532       case LIMIT:
13533       case LOOP:
13534       case MAP:
13535       case MAX:
13536       case MEMBER:
13537       case MERGE:
13538       case MIN:
13539       case MINUTE:
13540       case MLSLABEL:
13541       case MODIFY:
13542       case MOD:
13543       case MONTH:
13544       case NATURAL:
13545       case NEW:
13546       case NO:
13547       case NONEDITIONABLE:
13548       case NULLIF:
13549       case OBJECT:
13550       case OID:
13551       case OPAQUE:
13552       case OPEN:
13553       case OPERATOR:
13554       case ORGANIZATION:
13555       case OTHERS:
13556       case OVERRIDING:
13557       case PACKAGE:
13558       case PARTITION:
13559       case PRESERVE:
13560       case PRIVATE:
13561       case PROCEDURE:
13562       case RANGE:
13563       case RAW:
13564       case REAL:
13565       case RECORD:
13566       case REF:
13567       case RELEASE:
13568       case RELIES_ON:
13569       case RENAME:
13570       case RESULT:
13571       case RETURN:
13572       case RETURNING:
13573       case REVERSE:
13574       case ROLLBACK:
13575       case ROW:
13576       case ROWS:
13577       case ROWID:
13578       case ROWNUM:
13579       case SAVE:
13580       case SAVEPOINT:
13581       case SECOND:
13582       case SELF:
13583       case SET:
13584       case SPACE:
13585       case SQL:
13586       case SQLCODE:
13587       case SQLERRM:
13588       case STATIC:
13589       case SUBTYPE:
13590       case SUBSTITUTABLE:
13591       case SUCCESSFUL:
13592       case SYSDATE:
13593       case SYS_REFCURSOR:
13594       case TEMPORARY:
13595       case TIME:
13596       case TIMESTAMP:
13597       case TIMEZONE_REGION:
13598       case TIMEZONE_ABBR:
13599       case TIMEZONE_MINUTE:
13600       case TIMEZONE_HOUR:
13601       case TRANSACTION:
13602       case TRUE:
13603       case TYPE:
13604       case UNDER:
13605       case USING:
13606       case YES:
13607       case SHOW:
13608       case A:
13609       case DOUBLE:
13610       case DEC:
13611       case PRECISION:
13612       case INT:
13613       case NUMERIC:
13614       case NCHAR:
13615       case NVARCHAR2:
13616       case STRING:
13617       case UROWID:
13618       case VARRAY:
13619       case VARYING:
13620       case BFILE:
13621       case BLOB:
13622       case CLOB:
13623       case NCLOB:
13624       case YEAR:
13625       case LOCAL:
13626       case ZONE:
13627       case CHARACTER:
13628       case AFTER:
13629       case BEFORE:
13630       case OLD:
13631       case PARENT:
13632       case ANALYZE:
13633       case ASSOCIATE:
13634       case AUDIT:
13635       case COMPOUND:
13636       case DATABASE:
13637       case CALL:
13638       case DDL:
13639       case DISASSOCIATE:
13640       case EACH:
13641       case FOLLOWS:
13642       case LOGOFF:
13643       case LOGON:
13644       case NESTED:
13645       case NOAUDIT:
13646       case SCHEMA:
13647       case SERVERERROR:
13648       case SHUTDOWN:
13649       case STARTUP:
13650       case STATEMENT:
13651       case STATISTICS:
13652       case SUSPEND:
13653       case TRUNCATE:
13654       case WRAPPED:
13655       case LIBRARY:
13656       case NAME:
13657       case STRUCT:
13658       case CONTEXT:
13659       case PARAMETERS:
13660       case LENGTH:
13661       case TDO:
13662       case MAXLEN:
13663       case CHARSETID:
13664       case CHARSETFORM:
13665       case ACCEPT:
13666       case ACCESSIBLE:
13667       case COPY:
13668       case DEFINE:
13669       case DISCONNECT:
13670       case HOST:
13671       case PRINT:
13672       case QUIT:
13673       case REMARK:
13674       case UNDEFINE:
13675       case VARIABLE:
13676       case WHENEVER:
13677       case ATTACH:
13678       case CAST:
13679       case TREAT:
13680       case TRIM:
13681       case LEFT:
13682       case RIGHT:
13683       case BOTH:
13684       case EMPTY:
13685       case MULTISET:
13686       case SUBMULTISET:
13687       case LEADING:
13688       case TRAILING:
13689       case CHAR_CS:
13690       case NCHAR_CS:
13691       case DBTIMEZONE:
13692       case SESSIONTIMEZONE:
13693       case AUTHENTICATED:
13694       case LINK:
13695       case SHARED:
13696       case DIRECTORY:
13697       case USER:
13698       case IDENTIFIER:
13699       case QUOTED_LITERAL:
13700         label = UnqualifiedID();
13701         break;
13702       default:
13703         jj_la1[148] = jj_gen;
13704         ;
13705       }
13706       switch (jj_nt.kind) {
13707       case WHEN:
13708         jj_consume_token(WHEN);
13709         Expression();
13710         break;
13711       default:
13712         jj_la1[149] = jj_gen;
13713         ;
13714       }
13715         jjtree.closeNodeScope(jjtn000, true);
13716         jjtc000 = false;
13717         if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
13718     } catch (Throwable jjte000) {
13719           if (jjtc000) {
13720             jjtree.clearNodeScope(jjtn000);
13721             jjtc000 = false;
13722           } else {
13723             jjtree.popNode();
13724           }
13725           if (jjte000 instanceof RuntimeException) {
13726             {if (true) throw (RuntimeException)jjte000;}
13727           }
13728           if (jjte000 instanceof ParseException) {
13729             {if (true) throw (ParseException)jjte000;}
13730           }
13731           {if (true) throw (Error)jjte000;}
13732     } finally {
13733           if (jjtc000) {
13734             jjtree.closeNodeScope(jjtn000, true);
13735           }
13736     }
13737     throw new Error("Missing return statement in function");
13738   }
13739 
13740   final public ASTRaiseStatement RaiseStatement() throws ParseException {
13741  /*@bgen(jjtree) RaiseStatement */
13742  ASTRaiseStatement jjtn000 = new ASTRaiseStatement(this, JJTRAISESTATEMENT);
13743  boolean jjtc000 = true;
13744  jjtree.openNodeScope(jjtn000);PLSQLNode exception = null ;
13745     try {
13746       jj_consume_token(RAISE);
13747       switch (jj_nt.kind) {
13748       case REPLACE:
13749       case DEFINER:
13750       case CURRENT_USER:
13751       case LANGUAGE:
13752       case ADD:
13753       case AGGREGATE:
13754       case ARRAY:
13755       case AT:
13756       case ATTRIBUTE:
13757       case AUTHID:
13758       case BODY:
13759       case BULK:
13760       case BYTE:
13761       case CASCADE:
13762       case CLOSE:
13763       case COALESCE:
13764       case COLLECT:
13765       case COLUMN:
13766       case COMMENT:
13767       case COMMIT:
13768       case CONSTRUCTOR:
13769       case CONTINUE:
13770       case CONVERT:
13771       case CURRENT:
13772       case CURSOR:
13773       case DATA:
13774       case DAY:
13775       case DISABLE:
13776       case EDITIONABLE:
13777       case ELEMENT:
13778       case ENABLE:
13779       case ESCAPE:
13780       case EXCEPT:
13781       case EXCEPTIONS:
13782       case EXIT:
13783       case EXTERNAL:
13784       case EXTENDS:
13785       case EXTRACT:
13786       case FALSE:
13787       case FINAL:
13788       case FORCE:
13789       case FUNCTION:
13790       case GLOBAL:
13791       case HASH:
13792       case HEAP:
13793       case HOUR:
13794       case IMMEDIATE:
13795       case INDICES:
13796       case INDEXTYPE:
13797       case INDICATOR:
13798       case INSTANTIABLE:
13799       case INTERVAL:
13800       case INVALIDATE:
13801       case ISOLATION:
13802       case JAVA:
13803       case LEVEL:
13804       case LIMIT:
13805       case LOOP:
13806       case MAP:
13807       case MAX:
13808       case MEMBER:
13809       case MERGE:
13810       case MIN:
13811       case MINUTE:
13812       case MLSLABEL:
13813       case MODIFY:
13814       case MOD:
13815       case MONTH:
13816       case NATURAL:
13817       case NEW:
13818       case NO:
13819       case NONEDITIONABLE:
13820       case NULLIF:
13821       case OBJECT:
13822       case OID:
13823       case OPAQUE:
13824       case OPEN:
13825       case OPERATOR:
13826       case ORGANIZATION:
13827       case OTHERS:
13828       case OVERRIDING:
13829       case PACKAGE:
13830       case PARTITION:
13831       case PRESERVE:
13832       case PRIVATE:
13833       case PROCEDURE:
13834       case RANGE:
13835       case RAW:
13836       case REAL:
13837       case RECORD:
13838       case REF:
13839       case RELEASE:
13840       case RELIES_ON:
13841       case RENAME:
13842       case RESULT:
13843       case RETURN:
13844       case RETURNING:
13845       case REVERSE:
13846       case ROLLBACK:
13847       case ROW:
13848       case ROWS:
13849       case ROWID:
13850       case ROWNUM:
13851       case SAVE:
13852       case SAVEPOINT:
13853       case SECOND:
13854       case SELF:
13855       case SET:
13856       case SPACE:
13857       case SQL:
13858       case SQLCODE:
13859       case SQLERRM:
13860       case STATIC:
13861       case SUBTYPE:
13862       case SUBSTITUTABLE:
13863       case SUCCESSFUL:
13864       case SYSDATE:
13865       case SYS_REFCURSOR:
13866       case TEMPORARY:
13867       case TIME:
13868       case TIMESTAMP:
13869       case TIMEZONE_REGION:
13870       case TIMEZONE_ABBR:
13871       case TIMEZONE_MINUTE:
13872       case TIMEZONE_HOUR:
13873       case TRANSACTION:
13874       case TRUE:
13875       case TYPE:
13876       case UNDER:
13877       case USING:
13878       case YES:
13879       case SHOW:
13880       case A:
13881       case DOUBLE:
13882       case DEC:
13883       case PRECISION:
13884       case INT:
13885       case NUMERIC:
13886       case NCHAR:
13887       case NVARCHAR2:
13888       case STRING:
13889       case UROWID:
13890       case VARRAY:
13891       case VARYING:
13892       case BFILE:
13893       case BLOB:
13894       case CLOB:
13895       case NCLOB:
13896       case YEAR:
13897       case LOCAL:
13898       case ZONE:
13899       case CHARACTER:
13900       case AFTER:
13901       case BEFORE:
13902       case OLD:
13903       case PARENT:
13904       case ANALYZE:
13905       case ASSOCIATE:
13906       case AUDIT:
13907       case COMPOUND:
13908       case DATABASE:
13909       case CALL:
13910       case DDL:
13911       case DISASSOCIATE:
13912       case EACH:
13913       case FOLLOWS:
13914       case LOGOFF:
13915       case LOGON:
13916       case NESTED:
13917       case NOAUDIT:
13918       case SCHEMA:
13919       case SERVERERROR:
13920       case SHUTDOWN:
13921       case STARTUP:
13922       case STATEMENT:
13923       case STATISTICS:
13924       case SUSPEND:
13925       case TRUNCATE:
13926       case WRAPPED:
13927       case LIBRARY:
13928       case NAME:
13929       case STRUCT:
13930       case CONTEXT:
13931       case PARAMETERS:
13932       case LENGTH:
13933       case TDO:
13934       case MAXLEN:
13935       case CHARSETID:
13936       case CHARSETFORM:
13937       case ACCEPT:
13938       case ACCESSIBLE:
13939       case COPY:
13940       case DEFINE:
13941       case DISCONNECT:
13942       case HOST:
13943       case PRINT:
13944       case QUIT:
13945       case REMARK:
13946       case UNDEFINE:
13947       case VARIABLE:
13948       case WHENEVER:
13949       case ATTACH:
13950       case CAST:
13951       case TREAT:
13952       case TRIM:
13953       case LEFT:
13954       case RIGHT:
13955       case BOTH:
13956       case EMPTY:
13957       case MULTISET:
13958       case SUBMULTISET:
13959       case LEADING:
13960       case TRAILING:
13961       case CHAR_CS:
13962       case NCHAR_CS:
13963       case DBTIMEZONE:
13964       case SESSIONTIMEZONE:
13965       case AUTHENTICATED:
13966       case LINK:
13967       case SHARED:
13968       case DIRECTORY:
13969       case USER:
13970       case IDENTIFIER:
13971       case QUOTED_LITERAL:
13972         exception = QualifiedName();
13973         break;
13974       default:
13975         jj_la1[150] = jj_gen;
13976         ;
13977       }
13978         jjtree.closeNodeScope(jjtn000, true);
13979         jjtc000 = false;
13980         if (null != exception) { jjtn000.setImage(exception.getImage()) ; }  {if (true) return jjtn000 ;}
13981     } catch (Throwable jjte000) {
13982          if (jjtc000) {
13983            jjtree.clearNodeScope(jjtn000);
13984            jjtc000 = false;
13985          } else {
13986            jjtree.popNode();
13987          }
13988          if (jjte000 instanceof RuntimeException) {
13989            {if (true) throw (RuntimeException)jjte000;}
13990          }
13991          if (jjte000 instanceof ParseException) {
13992            {if (true) throw (ParseException)jjte000;}
13993          }
13994          {if (true) throw (Error)jjte000;}
13995     } finally {
13996          if (jjtc000) {
13997            jjtree.closeNodeScope(jjtn000, true);
13998          }
13999     }
14000     throw new Error("Missing return statement in function");
14001   }
14002 
14003   final public ASTCloseStatement CloseStatement() throws ParseException {
14004  /*@bgen(jjtree) CloseStatement */
14005  ASTCloseStatement jjtn000 = new ASTCloseStatement(this, JJTCLOSESTATEMENT);
14006  boolean jjtc000 = true;
14007  jjtree.openNodeScope(jjtn000);PLSQLNode cursor = null ;
14008     try {
14009       jj_consume_token(CLOSE);
14010       cursor = QualifiedName();
14011         jjtree.closeNodeScope(jjtn000, true);
14012         jjtc000 = false;
14013         jjtn000.setImage(cursor.getImage()) ; {if (true) return jjtn000 ;}
14014     } catch (Throwable jjte000) {
14015         if (jjtc000) {
14016           jjtree.clearNodeScope(jjtn000);
14017           jjtc000 = false;
14018         } else {
14019           jjtree.popNode();
14020         }
14021         if (jjte000 instanceof RuntimeException) {
14022           {if (true) throw (RuntimeException)jjte000;}
14023         }
14024         if (jjte000 instanceof ParseException) {
14025           {if (true) throw (ParseException)jjte000;}
14026         }
14027         {if (true) throw (Error)jjte000;}
14028     } finally {
14029         if (jjtc000) {
14030           jjtree.closeNodeScope(jjtn000, true);
14031         }
14032     }
14033     throw new Error("Missing return statement in function");
14034   }
14035 
14036   final public ASTOpenStatement OpenStatement() throws ParseException {
14037  /*@bgen(jjtree) OpenStatement */
14038   ASTOpenStatement jjtn000 = new ASTOpenStatement(this, JJTOPENSTATEMENT);
14039   boolean jjtc000 = true;
14040   jjtree.openNodeScope(jjtn000);
14041     try {
14042       jj_consume_token(OPEN);
14043       switch (jj_nt.kind) {
14044       case 5:
14045       case 16:
14046       case 17:
14047       case REPLACE:
14048       case DEFINER:
14049       case CURRENT_USER:
14050       case LANGUAGE:
14051       case ADD:
14052       case AGGREGATE:
14053       case ARRAY:
14054       case AT:
14055       case ATTRIBUTE:
14056       case AUTHID:
14057       case BODY:
14058       case BULK:
14059       case BYTE:
14060       case CASCADE:
14061       case CASE:
14062       case CLOSE:
14063       case COALESCE:
14064       case COLLECT:
14065       case COLUMN:
14066       case COMMENT:
14067       case COMMIT:
14068       case CONSTRUCTOR:
14069       case CONTINUE:
14070       case CONVERT:
14071       case CURRENT:
14072       case CURSOR:
14073       case DATA:
14074       case DATE:
14075       case DAY:
14076       case DISABLE:
14077       case EDITIONABLE:
14078       case ELEMENT:
14079       case ENABLE:
14080       case ESCAPE:
14081       case EXCEPT:
14082       case EXCEPTIONS:
14083       case EXIT:
14084       case EXTERNAL:
14085       case EXTENDS:
14086       case EXTRACT:
14087       case FALSE:
14088       case FINAL:
14089       case FORCE:
14090       case FUNCTION:
14091       case GLOBAL:
14092       case HASH:
14093       case HEAP:
14094       case HOUR:
14095       case IMMEDIATE:
14096       case INDICES:
14097       case INDEXTYPE:
14098       case INDICATOR:
14099       case INSTANTIABLE:
14100       case INTERVAL:
14101       case INVALIDATE:
14102       case ISOLATION:
14103       case JAVA:
14104       case LEVEL:
14105       case LIMIT:
14106       case LOOP:
14107       case MAP:
14108       case MAX:
14109       case MEMBER:
14110       case MERGE:
14111       case MIN:
14112       case MINUTE:
14113       case MLSLABEL:
14114       case MODIFY:
14115       case MOD:
14116       case MONTH:
14117       case NATURAL:
14118       case NEW:
14119       case NEW_DOT:
14120       case NO:
14121       case NONEDITIONABLE:
14122       case NOT:
14123       case NULL:
14124       case NULLIF:
14125       case OBJECT:
14126       case OID:
14127       case OPAQUE:
14128       case OPEN:
14129       case OPERATOR:
14130       case ORGANIZATION:
14131       case OTHERS:
14132       case OVERRIDING:
14133       case PACKAGE:
14134       case PARTITION:
14135       case PRESERVE:
14136       case PRIVATE:
14137       case PROCEDURE:
14138       case RANGE:
14139       case RAW:
14140       case REAL:
14141       case RECORD:
14142       case REF:
14143       case RELEASE:
14144       case RELIES_ON:
14145       case RENAME:
14146       case RESULT:
14147       case RETURN:
14148       case RETURNING:
14149       case REVERSE:
14150       case ROLLBACK:
14151       case ROW:
14152       case ROWS:
14153       case ROWID:
14154       case ROWNUM:
14155       case SAVE:
14156       case SAVEPOINT:
14157       case SECOND:
14158       case SELECT:
14159       case SELF:
14160       case SET:
14161       case SPACE:
14162       case SQL:
14163       case SQLCODE:
14164       case SQLERRM:
14165       case STATIC:
14166       case SUBTYPE:
14167       case SUBSTITUTABLE:
14168       case SUCCESSFUL:
14169       case SYSDATE:
14170       case SYS_REFCURSOR:
14171       case TEMPORARY:
14172       case TIME:
14173       case TIMESTAMP:
14174       case TIMEZONE_REGION:
14175       case TIMEZONE_ABBR:
14176       case TIMEZONE_MINUTE:
14177       case TIMEZONE_HOUR:
14178       case TRANSACTION:
14179       case TRUE:
14180       case TYPE:
14181       case UNDER:
14182       case USING:
14183       case YES:
14184       case SHOW:
14185       case A:
14186       case DOUBLE:
14187       case DEC:
14188       case PRECISION:
14189       case INT:
14190       case NUMERIC:
14191       case NCHAR:
14192       case NVARCHAR2:
14193       case STRING:
14194       case UROWID:
14195       case VARRAY:
14196       case VARYING:
14197       case BFILE:
14198       case BLOB:
14199       case CLOB:
14200       case NCLOB:
14201       case YEAR:
14202       case LOCAL:
14203       case WITH:
14204       case ZONE:
14205       case CHARACTER:
14206       case AFTER:
14207       case BEFORE:
14208       case OLD:
14209       case PARENT:
14210       case CC_IF:
14211       case ANALYZE:
14212       case ASSOCIATE:
14213       case AUDIT:
14214       case COMPOUND:
14215       case DATABASE:
14216       case CALL:
14217       case DDL:
14218       case DISASSOCIATE:
14219       case EACH:
14220       case FOLLOWS:
14221       case LOGOFF:
14222       case LOGON:
14223       case NESTED:
14224       case NOAUDIT:
14225       case SCHEMA:
14226       case SERVERERROR:
14227       case SHUTDOWN:
14228       case STARTUP:
14229       case STATEMENT:
14230       case STATISTICS:
14231       case SUSPEND:
14232       case TRUNCATE:
14233       case WRAPPED:
14234       case LIBRARY:
14235       case NAME:
14236       case STRUCT:
14237       case CONTEXT:
14238       case PARAMETERS:
14239       case LENGTH:
14240       case TDO:
14241       case MAXLEN:
14242       case CHARSETID:
14243       case CHARSETFORM:
14244       case ACCEPT:
14245       case ACCESSIBLE:
14246       case COPY:
14247       case DEFINE:
14248       case DISCONNECT:
14249       case HOST:
14250       case PRINT:
14251       case QUIT:
14252       case REMARK:
14253       case UNDEFINE:
14254       case VARIABLE:
14255       case WHENEVER:
14256       case ATTACH:
14257       case CAST:
14258       case TREAT:
14259       case TRIM:
14260       case LEFT:
14261       case RIGHT:
14262       case BOTH:
14263       case EMPTY:
14264       case MULTISET:
14265       case SUBMULTISET:
14266       case LEADING:
14267       case TRAILING:
14268       case CHAR_CS:
14269       case NCHAR_CS:
14270       case DBTIMEZONE:
14271       case SESSIONTIMEZONE:
14272       case AUTHENTICATED:
14273       case LINK:
14274       case SHARED:
14275       case DIRECTORY:
14276       case USER:
14277       case IDENTIFIER:
14278       case UNSIGNED_NUMERIC_LITERAL:
14279       case CHARACTER_LITERAL:
14280       case STRING_LITERAL:
14281       case QUOTED_LITERAL:
14282         Expression();
14283         break;
14284       default:
14285         jj_la1[151] = jj_gen;
14286         ;
14287       }
14288       switch (jj_nt.kind) {
14289       case FOR:
14290         jj_consume_token(FOR);
14291         Expression();
14292         switch (jj_nt.kind) {
14293         case USING:
14294           jj_consume_token(USING);
14295           Expression();
14296           label_34:
14297           while (true) {
14298             switch (jj_nt.kind) {
14299             case 6:
14300               ;
14301               break;
14302             default:
14303               jj_la1[152] = jj_gen;
14304               break label_34;
14305             }
14306             jj_consume_token(6);
14307             Expression();
14308           }
14309           break;
14310         default:
14311           jj_la1[153] = jj_gen;
14312           ;
14313         }
14314         break;
14315       default:
14316         jj_la1[154] = jj_gen;
14317         ;
14318       }
14319         jjtree.closeNodeScope(jjtn000, true);
14320         jjtc000 = false;
14321         {if (true) return jjtn000 ;}
14322     } catch (Throwable jjte000) {
14323            if (jjtc000) {
14324              jjtree.clearNodeScope(jjtn000);
14325              jjtc000 = false;
14326            } else {
14327              jjtree.popNode();
14328            }
14329            if (jjte000 instanceof RuntimeException) {
14330              {if (true) throw (RuntimeException)jjte000;}
14331            }
14332            if (jjte000 instanceof ParseException) {
14333              {if (true) throw (ParseException)jjte000;}
14334            }
14335            {if (true) throw (Error)jjte000;}
14336     } finally {
14337            if (jjtc000) {
14338              jjtree.closeNodeScope(jjtn000, true);
14339            }
14340     }
14341     throw new Error("Missing return statement in function");
14342   }
14343 
14344   final public ASTFetchStatement FetchStatement() throws ParseException {
14345  /*@bgen(jjtree) FetchStatement */
14346   ASTFetchStatement jjtn000 = new ASTFetchStatement(this, JJTFETCHSTATEMENT);
14347   boolean jjtc000 = true;
14348   jjtree.openNodeScope(jjtn000);
14349     try {
14350       jj_consume_token(FETCH);
14351       QualifiedName();
14352       switch (jj_nt.kind) {
14353       case BULK:
14354         jj_consume_token(BULK);
14355         jj_consume_token(COLLECT);
14356         break;
14357       default:
14358         jj_la1[155] = jj_gen;
14359         ;
14360       }
14361       jj_consume_token(INTO);
14362       Expression();
14363       label_35:
14364       while (true) {
14365         switch (jj_nt.kind) {
14366         case 6:
14367           ;
14368           break;
14369         default:
14370           jj_la1[156] = jj_gen;
14371           break label_35;
14372         }
14373         jj_consume_token(6);
14374         Expression();
14375       }
14376       switch (jj_nt.kind) {
14377       case LIMIT:
14378         jj_consume_token(LIMIT);
14379         Expression();
14380         break;
14381       default:
14382         jj_la1[157] = jj_gen;
14383         ;
14384       }
14385         jjtree.closeNodeScope(jjtn000, true);
14386         jjtc000 = false;
14387         {if (true) return jjtn000 ;}
14388     } catch (Throwable jjte000) {
14389            if (jjtc000) {
14390              jjtree.clearNodeScope(jjtn000);
14391              jjtc000 = false;
14392            } else {
14393              jjtree.popNode();
14394            }
14395            if (jjte000 instanceof RuntimeException) {
14396              {if (true) throw (RuntimeException)jjte000;}
14397            }
14398            if (jjte000 instanceof ParseException) {
14399              {if (true) throw (ParseException)jjte000;}
14400            }
14401            {if (true) throw (Error)jjte000;}
14402     } finally {
14403            if (jjtc000) {
14404              jjtree.closeNodeScope(jjtn000, true);
14405            }
14406     }
14407     throw new Error("Missing return statement in function");
14408   }
14409 
14410   final public ASTEmbeddedSqlStatement EmbeddedSqlStatement() throws ParseException {
14411  /*@bgen(jjtree) EmbeddedSqlStatement */
14412   ASTEmbeddedSqlStatement jjtn000 = new ASTEmbeddedSqlStatement(this, JJTEMBEDDEDSQLSTATEMENT);
14413   boolean jjtc000 = true;
14414   jjtree.openNodeScope(jjtn000);
14415     try {
14416       jj_consume_token(EXECUTE);
14417       jj_consume_token(IMMEDIATE);
14418       Expression();
14419       switch (jj_nt.kind) {
14420       case INTO:
14421         jj_consume_token(INTO);
14422         Name();
14423         label_36:
14424         while (true) {
14425           switch (jj_nt.kind) {
14426           case 6:
14427             ;
14428             break;
14429           default:
14430             jj_la1[158] = jj_gen;
14431             break label_36;
14432           }
14433           jj_consume_token(6);
14434           Name();
14435         }
14436         break;
14437       default:
14438         jj_la1[159] = jj_gen;
14439         ;
14440       }
14441       switch (jj_nt.kind) {
14442       case USING:
14443         jj_consume_token(USING);
14444         switch (jj_nt.kind) {
14445         case IN:
14446         case OUT:
14447           switch (jj_nt.kind) {
14448           case IN:
14449             jj_consume_token(IN);
14450             switch (jj_nt.kind) {
14451             case OUT:
14452               jj_consume_token(OUT);
14453               break;
14454             default:
14455               jj_la1[160] = jj_gen;
14456               ;
14457             }
14458             break;
14459           case OUT:
14460             jj_consume_token(OUT);
14461             break;
14462           default:
14463             jj_la1[161] = jj_gen;
14464             jj_consume_token(-1);
14465             throw new ParseException();
14466           }
14467           break;
14468         default:
14469           jj_la1[162] = jj_gen;
14470           ;
14471         }
14472         Expression();
14473         label_37:
14474         while (true) {
14475           switch (jj_nt.kind) {
14476           case 6:
14477             ;
14478             break;
14479           default:
14480             jj_la1[163] = jj_gen;
14481             break label_37;
14482           }
14483           jj_consume_token(6);
14484           switch (jj_nt.kind) {
14485           case IN:
14486           case OUT:
14487             switch (jj_nt.kind) {
14488             case IN:
14489               jj_consume_token(IN);
14490               switch (jj_nt.kind) {
14491               case OUT:
14492                 jj_consume_token(OUT);
14493                 break;
14494               default:
14495                 jj_la1[164] = jj_gen;
14496                 ;
14497               }
14498               break;
14499             case OUT:
14500               jj_consume_token(OUT);
14501               break;
14502             default:
14503               jj_la1[165] = jj_gen;
14504               jj_consume_token(-1);
14505               throw new ParseException();
14506             }
14507             break;
14508           default:
14509             jj_la1[166] = jj_gen;
14510             ;
14511           }
14512           Expression();
14513         }
14514         break;
14515       default:
14516         jj_la1[167] = jj_gen;
14517         ;
14518       }
14519       switch (jj_nt.kind) {
14520       case RETURN:
14521       case RETURNING:
14522         switch (jj_nt.kind) {
14523         case RETURN:
14524           jj_consume_token(RETURN);
14525           break;
14526         case RETURNING:
14527           jj_consume_token(RETURNING);
14528           break;
14529         default:
14530           jj_la1[168] = jj_gen;
14531           jj_consume_token(-1);
14532           throw new ParseException();
14533         }
14534         jj_consume_token(INTO);
14535         Expression();
14536         label_38:
14537         while (true) {
14538           switch (jj_nt.kind) {
14539           case 6:
14540             ;
14541             break;
14542           default:
14543             jj_la1[169] = jj_gen;
14544             break label_38;
14545           }
14546           jj_consume_token(6);
14547           Expression();
14548         }
14549         break;
14550       default:
14551         jj_la1[170] = jj_gen;
14552         ;
14553       }
14554       jj_consume_token(4);
14555         jjtree.closeNodeScope(jjtn000, true);
14556         jjtc000 = false;
14557         {if (true) return jjtn000 ;}
14558     } catch (Throwable jjte000) {
14559      if (jjtc000) {
14560        jjtree.clearNodeScope(jjtn000);
14561        jjtc000 = false;
14562      } else {
14563        jjtree.popNode();
14564      }
14565      if (jjte000 instanceof RuntimeException) {
14566        {if (true) throw (RuntimeException)jjte000;}
14567      }
14568      if (jjte000 instanceof ParseException) {
14569        {if (true) throw (ParseException)jjte000;}
14570      }
14571      {if (true) throw (Error)jjte000;}
14572     } finally {
14573      if (jjtc000) {
14574        jjtree.closeNodeScope(jjtn000, true);
14575      }
14576     }
14577     throw new Error("Missing return statement in function");
14578   }
14579 
14580   final public ASTPipelineStatement PipelineStatement() throws ParseException {
14581  /*@bgen(jjtree) PipelineStatement */
14582   ASTPipelineStatement jjtn000 = new ASTPipelineStatement(this, JJTPIPELINESTATEMENT);
14583   boolean jjtc000 = true;
14584   jjtree.openNodeScope(jjtn000);
14585     try {
14586       jj_consume_token(PIPE);
14587       jj_consume_token(ROW);
14588       Expression();
14589         jjtree.closeNodeScope(jjtn000, true);
14590         jjtc000 = false;
14591         {if (true) return jjtn000 ;}
14592     } catch (Throwable jjte000) {
14593           if (jjtc000) {
14594             jjtree.clearNodeScope(jjtn000);
14595             jjtc000 = false;
14596           } else {
14597             jjtree.popNode();
14598           }
14599           if (jjte000 instanceof RuntimeException) {
14600             {if (true) throw (RuntimeException)jjte000;}
14601           }
14602           if (jjte000 instanceof ParseException) {
14603             {if (true) throw (ParseException)jjte000;}
14604           }
14605           {if (true) throw (Error)jjte000;}
14606     } finally {
14607           if (jjtc000) {
14608             jjtree.closeNodeScope(jjtn000, true);
14609           }
14610     }
14611     throw new Error("Missing return statement in function");
14612   }
14613 
14614   final public ASTConditionalCompilationStatement ConditionalCompilationStatement() throws ParseException {
14615  /*@bgen(jjtree) ConditionalCompilationStatement */
14616   ASTConditionalCompilationStatement jjtn000 = new ASTConditionalCompilationStatement(this, JJTCONDITIONALCOMPILATIONSTATEMENT);
14617   boolean jjtc000 = true;
14618   jjtree.openNodeScope(jjtn000);
14619     try {
14620       switch (jj_nt.kind) {
14621       case CC_IF:
14622         jj_consume_token(CC_IF);
14623         ConditionalOrExpression();
14624         jj_consume_token(CC_THEN);
14625         label_39:
14626         while (true) {
14627           switch (jj_nt.kind) {
14628           case 5:
14629           case 16:
14630           case 17:
14631           case 21:
14632           case REPLACE:
14633           case DEFINER:
14634           case CURRENT_USER:
14635           case LANGUAGE:
14636           case ADD:
14637           case AGGREGATE:
14638           case ARRAY:
14639           case AT:
14640           case ATTRIBUTE:
14641           case AUTHID:
14642           case BEGIN:
14643           case BODY:
14644           case BULK:
14645           case BYTE:
14646           case CASCADE:
14647           case CASE:
14648           case CLOSE:
14649           case COALESCE:
14650           case COLLECT:
14651           case COLUMN:
14652           case COMMENT:
14653           case COMMIT:
14654           case CONSTRUCTOR:
14655           case CONTINUE:
14656           case CONVERT:
14657           case CURRENT:
14658           case CURSOR:
14659           case DATA:
14660           case DATE:
14661           case DAY:
14662           case DECLARE:
14663           case DELETE:
14664           case DISABLE:
14665           case EDITIONABLE:
14666           case ELEMENT:
14667           case ENABLE:
14668           case ESCAPE:
14669           case EXCEPT:
14670           case EXCEPTIONS:
14671           case EXECUTE:
14672           case EXIT:
14673           case EXTERNAL:
14674           case EXTENDS:
14675           case EXTRACT:
14676           case FALSE:
14677           case FETCH:
14678           case FINAL:
14679           case FOR:
14680           case FORALL:
14681           case FORCE:
14682           case FUNCTION:
14683           case GLOBAL:
14684           case GOTO:
14685           case HASH:
14686           case HEAP:
14687           case HOUR:
14688           case IF:
14689           case IMMEDIATE:
14690           case INDICES:
14691           case INDEXTYPE:
14692           case INDICATOR:
14693           case INSERT:
14694           case INSTANTIABLE:
14695           case INTERVAL:
14696           case INVALIDATE:
14697           case ISOLATION:
14698           case JAVA:
14699           case LEVEL:
14700           case LIMIT:
14701           case LOCK:
14702           case LOOP:
14703           case MAP:
14704           case MAX:
14705           case MEMBER:
14706           case MERGE:
14707           case MIN:
14708           case MINUTE:
14709           case MLSLABEL:
14710           case MODIFY:
14711           case MOD:
14712           case MONTH:
14713           case NATURAL:
14714           case NEW:
14715           case NEW_DOT:
14716           case NO:
14717           case NONEDITIONABLE:
14718           case NOT:
14719           case NULL:
14720           case NULLIF:
14721           case OBJECT:
14722           case OID:
14723           case OPAQUE:
14724           case OPEN:
14725           case OPERATOR:
14726           case ORGANIZATION:
14727           case OTHERS:
14728           case OVERRIDING:
14729           case PACKAGE:
14730           case PARTITION:
14731           case PIPE:
14732           case PRESERVE:
14733           case PRIVATE:
14734           case PROCEDURE:
14735           case RAISE:
14736           case RANGE:
14737           case RAW:
14738           case REAL:
14739           case RECORD:
14740           case REF:
14741           case RELEASE:
14742           case RELIES_ON:
14743           case RENAME:
14744           case RESULT:
14745           case RETURN:
14746           case RETURNING:
14747           case REVERSE:
14748           case ROLLBACK:
14749           case ROW:
14750           case ROWS:
14751           case ROWID:
14752           case ROWNUM:
14753           case SAVE:
14754           case SAVEPOINT:
14755           case SECOND:
14756           case SELECT:
14757           case SELF:
14758           case SET:
14759           case SPACE:
14760           case SQL:
14761           case SQLCODE:
14762           case SQLERRM:
14763           case STATIC:
14764           case SUBTYPE:
14765           case SUBSTITUTABLE:
14766           case SUCCESSFUL:
14767           case SYSDATE:
14768           case SYS_REFCURSOR:
14769           case TEMPORARY:
14770           case TIME:
14771           case TIMESTAMP:
14772           case TIMEZONE_REGION:
14773           case TIMEZONE_ABBR:
14774           case TIMEZONE_MINUTE:
14775           case TIMEZONE_HOUR:
14776           case TRANSACTION:
14777           case TRUE:
14778           case TYPE:
14779           case UNDER:
14780           case USING:
14781           case WHILE:
14782           case YES:
14783           case SHOW:
14784           case A:
14785           case UPDATE:
14786           case DOUBLE:
14787           case DEC:
14788           case PRECISION:
14789           case INT:
14790           case NUMERIC:
14791           case NCHAR:
14792           case NVARCHAR2:
14793           case STRING:
14794           case UROWID:
14795           case VARRAY:
14796           case VARYING:
14797           case BFILE:
14798           case BLOB:
14799           case CLOB:
14800           case NCLOB:
14801           case YEAR:
14802           case LOCAL:
14803           case WITH:
14804           case ZONE:
14805           case CHARACTER:
14806           case AFTER:
14807           case BEFORE:
14808           case OLD:
14809           case PARENT:
14810           case CC_IF:
14811           case CC_ERROR:
14812           case ANALYZE:
14813           case ASSOCIATE:
14814           case AUDIT:
14815           case COMPOUND:
14816           case DATABASE:
14817           case CALL:
14818           case DDL:
14819           case DISASSOCIATE:
14820           case EACH:
14821           case FOLLOWS:
14822           case LOGOFF:
14823           case LOGON:
14824           case NESTED:
14825           case NOAUDIT:
14826           case SCHEMA:
14827           case SERVERERROR:
14828           case SHUTDOWN:
14829           case STARTUP:
14830           case STATEMENT:
14831           case STATISTICS:
14832           case SUSPEND:
14833           case TRUNCATE:
14834           case WRAPPED:
14835           case LIBRARY:
14836           case NAME:
14837           case STRUCT:
14838           case CONTEXT:
14839           case PARAMETERS:
14840           case LENGTH:
14841           case TDO:
14842           case MAXLEN:
14843           case CHARSETID:
14844           case CHARSETFORM:
14845           case ACCEPT:
14846           case ACCESSIBLE:
14847           case COPY:
14848           case DEFINE:
14849           case DISCONNECT:
14850           case HOST:
14851           case PRINT:
14852           case QUIT:
14853           case REMARK:
14854           case UNDEFINE:
14855           case VARIABLE:
14856           case WHENEVER:
14857           case ATTACH:
14858           case CAST:
14859           case TREAT:
14860           case TRIM:
14861           case LEFT:
14862           case RIGHT:
14863           case BOTH:
14864           case EMPTY:
14865           case MULTISET:
14866           case SUBMULTISET:
14867           case LEADING:
14868           case TRAILING:
14869           case CHAR_CS:
14870           case NCHAR_CS:
14871           case DBTIMEZONE:
14872           case SESSIONTIMEZONE:
14873           case AUTHENTICATED:
14874           case LINK:
14875           case SHARED:
14876           case DIRECTORY:
14877           case USER:
14878           case IDENTIFIER:
14879           case UNSIGNED_NUMERIC_LITERAL:
14880           case CHARACTER_LITERAL:
14881           case STRING_LITERAL:
14882           case QUOTED_LITERAL:
14883             ;
14884             break;
14885           default:
14886             jj_la1[171] = jj_gen;
14887             break label_39;
14888           }
14889           Statement();
14890         }
14891         label_40:
14892         while (true) {
14893           switch (jj_nt.kind) {
14894           case CC_ELSIF:
14895             ;
14896             break;
14897           default:
14898             jj_la1[172] = jj_gen;
14899             break label_40;
14900           }
14901           jj_consume_token(CC_ELSIF);
14902           ConditionalOrExpression();
14903           jj_consume_token(CC_THEN);
14904           label_41:
14905           while (true) {
14906             Statement();
14907             switch (jj_nt.kind) {
14908             case 5:
14909             case 16:
14910             case 17:
14911             case 21:
14912             case REPLACE:
14913             case DEFINER:
14914             case CURRENT_USER:
14915             case LANGUAGE:
14916             case ADD:
14917             case AGGREGATE:
14918             case ARRAY:
14919             case AT:
14920             case ATTRIBUTE:
14921             case AUTHID:
14922             case BEGIN:
14923             case BODY:
14924             case BULK:
14925             case BYTE:
14926             case CASCADE:
14927             case CASE:
14928             case CLOSE:
14929             case COALESCE:
14930             case COLLECT:
14931             case COLUMN:
14932             case COMMENT:
14933             case COMMIT:
14934             case CONSTRUCTOR:
14935             case CONTINUE:
14936             case CONVERT:
14937             case CURRENT:
14938             case CURSOR:
14939             case DATA:
14940             case DATE:
14941             case DAY:
14942             case DECLARE:
14943             case DELETE:
14944             case DISABLE:
14945             case EDITIONABLE:
14946             case ELEMENT:
14947             case ENABLE:
14948             case ESCAPE:
14949             case EXCEPT:
14950             case EXCEPTIONS:
14951             case EXECUTE:
14952             case EXIT:
14953             case EXTERNAL:
14954             case EXTENDS:
14955             case EXTRACT:
14956             case FALSE:
14957             case FETCH:
14958             case FINAL:
14959             case FOR:
14960             case FORALL:
14961             case FORCE:
14962             case FUNCTION:
14963             case GLOBAL:
14964             case GOTO:
14965             case HASH:
14966             case HEAP:
14967             case HOUR:
14968             case IF:
14969             case IMMEDIATE:
14970             case INDICES:
14971             case INDEXTYPE:
14972             case INDICATOR:
14973             case INSERT:
14974             case INSTANTIABLE:
14975             case INTERVAL:
14976             case INVALIDATE:
14977             case ISOLATION:
14978             case JAVA:
14979             case LEVEL:
14980             case LIMIT:
14981             case LOCK:
14982             case LOOP:
14983             case MAP:
14984             case MAX:
14985             case MEMBER:
14986             case MERGE:
14987             case MIN:
14988             case MINUTE:
14989             case MLSLABEL:
14990             case MODIFY:
14991             case MOD:
14992             case MONTH:
14993             case NATURAL:
14994             case NEW:
14995             case NEW_DOT:
14996             case NO:
14997             case NONEDITIONABLE:
14998             case NOT:
14999             case NULL:
15000             case NULLIF:
15001             case OBJECT:
15002             case OID:
15003             case OPAQUE:
15004             case OPEN:
15005             case OPERATOR:
15006             case ORGANIZATION:
15007             case OTHERS:
15008             case OVERRIDING:
15009             case PACKAGE:
15010             case PARTITION:
15011             case PIPE:
15012             case PRESERVE:
15013             case PRIVATE:
15014             case PROCEDURE:
15015             case RAISE:
15016             case RANGE:
15017             case RAW:
15018             case REAL:
15019             case RECORD:
15020             case REF:
15021             case RELEASE:
15022             case RELIES_ON:
15023             case RENAME:
15024             case RESULT:
15025             case RETURN:
15026             case RETURNING:
15027             case REVERSE:
15028             case ROLLBACK:
15029             case ROW:
15030             case ROWS:
15031             case ROWID:
15032             case ROWNUM:
15033             case SAVE:
15034             case SAVEPOINT:
15035             case SECOND:
15036             case SELECT:
15037             case SELF:
15038             case SET:
15039             case SPACE:
15040             case SQL:
15041             case SQLCODE:
15042             case SQLERRM:
15043             case STATIC:
15044             case SUBTYPE:
15045             case SUBSTITUTABLE:
15046             case SUCCESSFUL:
15047             case SYSDATE:
15048             case SYS_REFCURSOR:
15049             case TEMPORARY:
15050             case TIME:
15051             case TIMESTAMP:
15052             case TIMEZONE_REGION:
15053             case TIMEZONE_ABBR:
15054             case TIMEZONE_MINUTE:
15055             case TIMEZONE_HOUR:
15056             case TRANSACTION:
15057             case TRUE:
15058             case TYPE:
15059             case UNDER:
15060             case USING:
15061             case WHILE:
15062             case YES:
15063             case SHOW:
15064             case A:
15065             case UPDATE:
15066             case DOUBLE:
15067             case DEC:
15068             case PRECISION:
15069             case INT:
15070             case NUMERIC:
15071             case NCHAR:
15072             case NVARCHAR2:
15073             case STRING:
15074             case UROWID:
15075             case VARRAY:
15076             case VARYING:
15077             case BFILE:
15078             case BLOB:
15079             case CLOB:
15080             case NCLOB:
15081             case YEAR:
15082             case LOCAL:
15083             case WITH:
15084             case ZONE:
15085             case CHARACTER:
15086             case AFTER:
15087             case BEFORE:
15088             case OLD:
15089             case PARENT:
15090             case CC_IF:
15091             case CC_ERROR:
15092             case ANALYZE:
15093             case ASSOCIATE:
15094             case AUDIT:
15095             case COMPOUND:
15096             case DATABASE:
15097             case CALL:
15098             case DDL:
15099             case DISASSOCIATE:
15100             case EACH:
15101             case FOLLOWS:
15102             case LOGOFF:
15103             case LOGON:
15104             case NESTED:
15105             case NOAUDIT:
15106             case SCHEMA:
15107             case SERVERERROR:
15108             case SHUTDOWN:
15109             case STARTUP:
15110             case STATEMENT:
15111             case STATISTICS:
15112             case SUSPEND:
15113             case TRUNCATE:
15114             case WRAPPED:
15115             case LIBRARY:
15116             case NAME:
15117             case STRUCT:
15118             case CONTEXT:
15119             case PARAMETERS:
15120             case LENGTH:
15121             case TDO:
15122             case MAXLEN:
15123             case CHARSETID:
15124             case CHARSETFORM:
15125             case ACCEPT:
15126             case ACCESSIBLE:
15127             case COPY:
15128             case DEFINE:
15129             case DISCONNECT:
15130             case HOST:
15131             case PRINT:
15132             case QUIT:
15133             case REMARK:
15134             case UNDEFINE:
15135             case VARIABLE:
15136             case WHENEVER:
15137             case ATTACH:
15138             case CAST:
15139             case TREAT:
15140             case TRIM:
15141             case LEFT:
15142             case RIGHT:
15143             case BOTH:
15144             case EMPTY:
15145             case MULTISET:
15146             case SUBMULTISET:
15147             case LEADING:
15148             case TRAILING:
15149             case CHAR_CS:
15150             case NCHAR_CS:
15151             case DBTIMEZONE:
15152             case SESSIONTIMEZONE:
15153             case AUTHENTICATED:
15154             case LINK:
15155             case SHARED:
15156             case DIRECTORY:
15157             case USER:
15158             case IDENTIFIER:
15159             case UNSIGNED_NUMERIC_LITERAL:
15160             case CHARACTER_LITERAL:
15161             case STRING_LITERAL:
15162             case QUOTED_LITERAL:
15163               ;
15164               break;
15165             default:
15166               jj_la1[173] = jj_gen;
15167               break label_41;
15168             }
15169           }
15170         }
15171         label_42:
15172         while (true) {
15173           switch (jj_nt.kind) {
15174           case CC_ELSE:
15175             ;
15176             break;
15177           default:
15178             jj_la1[174] = jj_gen;
15179             break label_42;
15180           }
15181           jj_consume_token(CC_ELSE);
15182           label_43:
15183           while (true) {
15184             Statement();
15185             switch (jj_nt.kind) {
15186             case 5:
15187             case 16:
15188             case 17:
15189             case 21:
15190             case REPLACE:
15191             case DEFINER:
15192             case CURRENT_USER:
15193             case LANGUAGE:
15194             case ADD:
15195             case AGGREGATE:
15196             case ARRAY:
15197             case AT:
15198             case ATTRIBUTE:
15199             case AUTHID:
15200             case BEGIN:
15201             case BODY:
15202             case BULK:
15203             case BYTE:
15204             case CASCADE:
15205             case CASE:
15206             case CLOSE:
15207             case COALESCE:
15208             case COLLECT:
15209             case COLUMN:
15210             case COMMENT:
15211             case COMMIT:
15212             case CONSTRUCTOR:
15213             case CONTINUE:
15214             case CONVERT:
15215             case CURRENT:
15216             case CURSOR:
15217             case DATA:
15218             case DATE:
15219             case DAY:
15220             case DECLARE:
15221             case DELETE:
15222             case DISABLE:
15223             case EDITIONABLE:
15224             case ELEMENT:
15225             case ENABLE:
15226             case ESCAPE:
15227             case EXCEPT:
15228             case EXCEPTIONS:
15229             case EXECUTE:
15230             case EXIT:
15231             case EXTERNAL:
15232             case EXTENDS:
15233             case EXTRACT:
15234             case FALSE:
15235             case FETCH:
15236             case FINAL:
15237             case FOR:
15238             case FORALL:
15239             case FORCE:
15240             case FUNCTION:
15241             case GLOBAL:
15242             case GOTO:
15243             case HASH:
15244             case HEAP:
15245             case HOUR:
15246             case IF:
15247             case IMMEDIATE:
15248             case INDICES:
15249             case INDEXTYPE:
15250             case INDICATOR:
15251             case INSERT:
15252             case INSTANTIABLE:
15253             case INTERVAL:
15254             case INVALIDATE:
15255             case ISOLATION:
15256             case JAVA:
15257             case LEVEL:
15258             case LIMIT:
15259             case LOCK:
15260             case LOOP:
15261             case MAP:
15262             case MAX:
15263             case MEMBER:
15264             case MERGE:
15265             case MIN:
15266             case MINUTE:
15267             case MLSLABEL:
15268             case MODIFY:
15269             case MOD:
15270             case MONTH:
15271             case NATURAL:
15272             case NEW:
15273             case NEW_DOT:
15274             case NO:
15275             case NONEDITIONABLE:
15276             case NOT:
15277             case NULL:
15278             case NULLIF:
15279             case OBJECT:
15280             case OID:
15281             case OPAQUE:
15282             case OPEN:
15283             case OPERATOR:
15284             case ORGANIZATION:
15285             case OTHERS:
15286             case OVERRIDING:
15287             case PACKAGE:
15288             case PARTITION:
15289             case PIPE:
15290             case PRESERVE:
15291             case PRIVATE:
15292             case PROCEDURE:
15293             case RAISE:
15294             case RANGE:
15295             case RAW:
15296             case REAL:
15297             case RECORD:
15298             case REF:
15299             case RELEASE:
15300             case RELIES_ON:
15301             case RENAME:
15302             case RESULT:
15303             case RETURN:
15304             case RETURNING:
15305             case REVERSE:
15306             case ROLLBACK:
15307             case ROW:
15308             case ROWS:
15309             case ROWID:
15310             case ROWNUM:
15311             case SAVE:
15312             case SAVEPOINT:
15313             case SECOND:
15314             case SELECT:
15315             case SELF:
15316             case SET:
15317             case SPACE:
15318             case SQL:
15319             case SQLCODE:
15320             case SQLERRM:
15321             case STATIC:
15322             case SUBTYPE:
15323             case SUBSTITUTABLE:
15324             case SUCCESSFUL:
15325             case SYSDATE:
15326             case SYS_REFCURSOR:
15327             case TEMPORARY:
15328             case TIME:
15329             case TIMESTAMP:
15330             case TIMEZONE_REGION:
15331             case TIMEZONE_ABBR:
15332             case TIMEZONE_MINUTE:
15333             case TIMEZONE_HOUR:
15334             case TRANSACTION:
15335             case TRUE:
15336             case TYPE:
15337             case UNDER:
15338             case USING:
15339             case WHILE:
15340             case YES:
15341             case SHOW:
15342             case A:
15343             case UPDATE:
15344             case DOUBLE:
15345             case DEC:
15346             case PRECISION:
15347             case INT:
15348             case NUMERIC:
15349             case NCHAR:
15350             case NVARCHAR2:
15351             case STRING:
15352             case UROWID:
15353             case VARRAY:
15354             case VARYING:
15355             case BFILE:
15356             case BLOB:
15357             case CLOB:
15358             case NCLOB:
15359             case YEAR:
15360             case LOCAL:
15361             case WITH:
15362             case ZONE:
15363             case CHARACTER:
15364             case AFTER:
15365             case BEFORE:
15366             case OLD:
15367             case PARENT:
15368             case CC_IF:
15369             case CC_ERROR:
15370             case ANALYZE:
15371             case ASSOCIATE:
15372             case AUDIT:
15373             case COMPOUND:
15374             case DATABASE:
15375             case CALL:
15376             case DDL:
15377             case DISASSOCIATE:
15378             case EACH:
15379             case FOLLOWS:
15380             case LOGOFF:
15381             case LOGON:
15382             case NESTED:
15383             case NOAUDIT:
15384             case SCHEMA:
15385             case SERVERERROR:
15386             case SHUTDOWN:
15387             case STARTUP:
15388             case STATEMENT:
15389             case STATISTICS:
15390             case SUSPEND:
15391             case TRUNCATE:
15392             case WRAPPED:
15393             case LIBRARY:
15394             case NAME:
15395             case STRUCT:
15396             case CONTEXT:
15397             case PARAMETERS:
15398             case LENGTH:
15399             case TDO:
15400             case MAXLEN:
15401             case CHARSETID:
15402             case CHARSETFORM:
15403             case ACCEPT:
15404             case ACCESSIBLE:
15405             case COPY:
15406             case DEFINE:
15407             case DISCONNECT:
15408             case HOST:
15409             case PRINT:
15410             case QUIT:
15411             case REMARK:
15412             case UNDEFINE:
15413             case VARIABLE:
15414             case WHENEVER:
15415             case ATTACH:
15416             case CAST:
15417             case TREAT:
15418             case TRIM:
15419             case LEFT:
15420             case RIGHT:
15421             case BOTH:
15422             case EMPTY:
15423             case MULTISET:
15424             case SUBMULTISET:
15425             case LEADING:
15426             case TRAILING:
15427             case CHAR_CS:
15428             case NCHAR_CS:
15429             case DBTIMEZONE:
15430             case SESSIONTIMEZONE:
15431             case AUTHENTICATED:
15432             case LINK:
15433             case SHARED:
15434             case DIRECTORY:
15435             case USER:
15436             case IDENTIFIER:
15437             case UNSIGNED_NUMERIC_LITERAL:
15438             case CHARACTER_LITERAL:
15439             case STRING_LITERAL:
15440             case QUOTED_LITERAL:
15441               ;
15442               break;
15443             default:
15444               jj_la1[175] = jj_gen;
15445               break label_43;
15446             }
15447           }
15448         }
15449         jj_consume_token(CC_END);
15450         break;
15451       case CC_ERROR:
15452         jj_consume_token(CC_ERROR);
15453         Expression();
15454         jj_consume_token(CC_END);
15455         break;
15456       default:
15457         jj_la1[176] = jj_gen;
15458         jj_consume_token(-1);
15459         throw new ParseException();
15460       }
15461         jjtree.closeNodeScope(jjtn000, true);
15462         jjtc000 = false;
15463         {if (true) return jjtn000 ;}
15464     } catch (Throwable jjte000) {
15465           if (jjtc000) {
15466             jjtree.clearNodeScope(jjtn000);
15467             jjtc000 = false;
15468           } else {
15469             jjtree.popNode();
15470           }
15471           if (jjte000 instanceof RuntimeException) {
15472             {if (true) throw (RuntimeException)jjte000;}
15473           }
15474           if (jjte000 instanceof ParseException) {
15475             {if (true) throw (ParseException)jjte000;}
15476           }
15477           {if (true) throw (Error)jjte000;}
15478     } finally {
15479           if (jjtc000) {
15480             jjtree.closeNodeScope(jjtn000, true);
15481           }
15482     }
15483     throw new Error("Missing return statement in function");
15484   }
15485 
15486   final public ASTSubTypeDefinition SubTypeDefinition() throws ParseException {
15487  /*@bgen(jjtree) SubTypeDefinition */
15488         ASTSubTypeDefinition jjtn000 = new ASTSubTypeDefinition(this, JJTSUBTYPEDEFINITION);
15489         boolean jjtc000 = true;
15490         jjtree.openNodeScope(jjtn000);Token start, subtype_name=null, constraint=null, base_type=null;
15491         Token collection = null, collection2 = null;
15492         PLSQLNode name = null;
15493         PLSQLNode startElement = null, endElement = null;
15494         PLSQLNode baseType = null, returnType = null, indexBy = null ;
15495         int lastField = 0;
15496     try {
15497       switch (jj_nt.kind) {
15498       case SUBTYPE:
15499         jj_consume_token(SUBTYPE);
15500         name = QualifiedID();
15501         jj_consume_token(IS);
15502         Datatype();
15503         switch (jj_nt.kind) {
15504         case 5:
15505         case RANGE:
15506           switch (jj_nt.kind) {
15507           case 5:
15508             jj_consume_token(5);
15509             jj_consume_token(IDENTIFIER);
15510             jj_consume_token(7);
15511             break;
15512           case RANGE:
15513             jj_consume_token(RANGE);
15514             UnaryExpression(true);
15515             jj_consume_token(12);
15516             UnaryExpression(true);
15517             break;
15518           default:
15519             jj_la1[177] = jj_gen;
15520             jj_consume_token(-1);
15521             throw new ParseException();
15522           }
15523           break;
15524         default:
15525           jj_la1[178] = jj_gen;
15526           ;
15527         }
15528         switch (jj_nt.kind) {
15529         case NOT:
15530           jj_consume_token(NOT);
15531           jj_consume_token(NULL);
15532           break;
15533         default:
15534           jj_la1[179] = jj_gen;
15535           ;
15536         }
15537         break;
15538       case TYPE:
15539         jj_consume_token(TYPE);
15540         name = QualifiedID();
15541         switch (jj_nt.kind) {
15542         case IS:
15543           jj_consume_token(IS);
15544           break;
15545         case AS:
15546           jj_consume_token(AS);
15547           break;
15548         default:
15549           jj_la1[180] = jj_gen;
15550           jj_consume_token(-1);
15551           throw new ParseException();
15552         }
15553         if (jj_2_44(2)) {
15554           jj_consume_token(NEW);
15555           switch (jj_nt.kind) {
15556           case CHAR_BASE:
15557             jj_consume_token(CHAR_BASE);
15558             break;
15559           case DATE_BASE:
15560             jj_consume_token(DATE_BASE);
15561             break;
15562           case CLOB_BASE:
15563             jj_consume_token(CLOB_BASE);
15564             break;
15565           case BLOB_BASE:
15566             jj_consume_token(BLOB_BASE);
15567             break;
15568           case BFILE_BASE:
15569             jj_consume_token(BFILE_BASE);
15570             break;
15571           case NUMBER_BASE:
15572             jj_consume_token(NUMBER_BASE);
15573             break;
15574           default:
15575             jj_la1[181] = jj_gen;
15576             jj_consume_token(-1);
15577             throw new ParseException();
15578           }
15579         } else {
15580           switch (jj_nt.kind) {
15581           case OBJECT:
15582             jj_consume_token(OBJECT);
15583             jj_consume_token(5);
15584             FieldDeclaration();
15585             label_44:
15586             while (true) {
15587               switch (jj_nt.kind) {
15588               case 6:
15589                 ;
15590                 break;
15591               default:
15592                 jj_la1[182] = jj_gen;
15593                 break label_44;
15594               }
15595               jj_consume_token(6);
15596               FieldDeclaration();
15597             }
15598             jj_consume_token(7);
15599             break;
15600           case RECORD:
15601             jj_consume_token(RECORD);
15602             jj_consume_token(5);
15603             FieldDeclaration();
15604             label_45:
15605             while (true) {
15606               switch (jj_nt.kind) {
15607               case 6:
15608                 ;
15609                 break;
15610               default:
15611                 jj_la1[183] = jj_gen;
15612                 break label_45;
15613               }
15614               jj_consume_token(6);
15615               FieldDeclaration();
15616             }
15617             jj_consume_token(7);
15618             break;
15619           case TABLE:
15620           case VARRAY:
15621           case VARYING:
15622             switch (jj_nt.kind) {
15623             case TABLE:
15624               jj_consume_token(TABLE);
15625               break;
15626             case VARRAY:
15627               jj_consume_token(VARRAY);
15628               break;
15629             case VARYING:
15630               jj_consume_token(VARYING);
15631               jj_consume_token(ARRAY);
15632               break;
15633             default:
15634               jj_la1[184] = jj_gen;
15635               jj_consume_token(-1);
15636               throw new ParseException();
15637             }
15638             switch (jj_nt.kind) {
15639             case 5:
15640               jj_consume_token(5);
15641               NumericLiteral();
15642               jj_consume_token(7);
15643               break;
15644             default:
15645               jj_la1[185] = jj_gen;
15646               ;
15647             }
15648             jj_consume_token(OF);
15649             Datatype();
15650             switch (jj_nt.kind) {
15651             case NOT:
15652               jj_consume_token(NOT);
15653               jj_consume_token(NULL);
15654               break;
15655             default:
15656               jj_la1[186] = jj_gen;
15657               ;
15658             }
15659             switch (jj_nt.kind) {
15660             case INDEX:
15661               jj_consume_token(INDEX);
15662               jj_consume_token(BY);
15663               Datatype();
15664               break;
15665             default:
15666               jj_la1[187] = jj_gen;
15667               ;
15668             }
15669             break;
15670           case REF:
15671             jj_consume_token(REF);
15672             jj_consume_token(CURSOR);
15673             switch (jj_nt.kind) {
15674             case RETURN:
15675               jj_consume_token(RETURN);
15676               Datatype();
15677               break;
15678             default:
15679               jj_la1[188] = jj_gen;
15680               ;
15681             }
15682             break;
15683           case 5:
15684             jj_consume_token(5);
15685             Expression();
15686             label_46:
15687             while (true) {
15688               switch (jj_nt.kind) {
15689               case 6:
15690                 ;
15691                 break;
15692               default:
15693                 jj_la1[189] = jj_gen;
15694                 break label_46;
15695               }
15696               jj_consume_token(6);
15697               Expression();
15698             }
15699             jj_consume_token(7);
15700             break;
15701           case REPLACE:
15702           case DEFINER:
15703           case CURRENT_USER:
15704           case LANGUAGE:
15705           case ADD:
15706           case AGGREGATE:
15707           case ARRAY:
15708           case AT:
15709           case ATTRIBUTE:
15710           case AUTHID:
15711           case BINARY_INTEGER:
15712           case BODY:
15713           case BOOLEAN:
15714           case BULK:
15715           case BYTE:
15716           case CASCADE:
15717           case CHAR:
15718           case CHAR_BASE:
15719           case CLOSE:
15720           case COALESCE:
15721           case COLLECT:
15722           case COLUMN:
15723           case COMMENT:
15724           case COMMIT:
15725           case CONSTRUCTOR:
15726           case CONTINUE:
15727           case CONVERT:
15728           case CURRENT:
15729           case CURSOR:
15730           case DATA:
15731           case DATE:
15732           case DAY:
15733           case DECIMAL:
15734           case DISABLE:
15735           case EDITIONABLE:
15736           case ELEMENT:
15737           case ENABLE:
15738           case ESCAPE:
15739           case EXCEPT:
15740           case EXCEPTIONS:
15741           case EXIT:
15742           case EXTERNAL:
15743           case EXTENDS:
15744           case EXTRACT:
15745           case FALSE:
15746           case FINAL:
15747           case FLOAT:
15748           case FORCE:
15749           case FUNCTION:
15750           case GLOBAL:
15751           case HASH:
15752           case HEAP:
15753           case HOUR:
15754           case IMMEDIATE:
15755           case INDICES:
15756           case INDEXTYPE:
15757           case INDICATOR:
15758           case INSTANTIABLE:
15759           case INTEGER:
15760           case INTERVAL:
15761           case INVALIDATE:
15762           case ISOLATION:
15763           case JAVA:
15764           case LEVEL:
15765           case LIMIT:
15766           case LONG:
15767           case LOOP:
15768           case MAP:
15769           case MAX:
15770           case MEMBER:
15771           case MERGE:
15772           case MIN:
15773           case MINUTE:
15774           case MLSLABEL:
15775           case MODIFY:
15776           case MOD:
15777           case MONTH:
15778           case NATURAL:
15779           case NATURALN:
15780           case NEW:
15781           case NO:
15782           case NONEDITIONABLE:
15783           case NULLIF:
15784           case NUMBER:
15785           case BFILE_BASE:
15786           case BLOB_BASE:
15787           case CLOB_BASE:
15788           case DATE_BASE:
15789           case NUMBER_BASE:
15790           case OID:
15791           case OPAQUE:
15792           case OPEN:
15793           case OPERATOR:
15794           case ORGANIZATION:
15795           case OTHERS:
15796           case OVERRIDING:
15797           case PACKAGE:
15798           case PARTITION:
15799           case PLS_INTEGER:
15800           case POSITIVE:
15801           case POSITIVEN:
15802           case PRESERVE:
15803           case PRIVATE:
15804           case PROCEDURE:
15805           case RANGE:
15806           case RAW:
15807           case REAL:
15808           case RELEASE:
15809           case RELIES_ON:
15810           case RENAME:
15811           case RESULT:
15812           case RETURN:
15813           case RETURNING:
15814           case REVERSE:
15815           case ROLLBACK:
15816           case ROW:
15817           case ROWS:
15818           case ROWID:
15819           case ROWNUM:
15820           case SAVE:
15821           case SAVEPOINT:
15822           case SECOND:
15823           case SELF:
15824           case SET:
15825           case SMALLINT:
15826           case SPACE:
15827           case SQL:
15828           case SQLCODE:
15829           case SQLERRM:
15830           case STATIC:
15831           case SUBTYPE:
15832           case SUBSTITUTABLE:
15833           case SUCCESSFUL:
15834           case SYSDATE:
15835           case SYS_REFCURSOR:
15836           case TEMPORARY:
15837           case TIME:
15838           case TIMESTAMP:
15839           case TIMEZONE_REGION:
15840           case TIMEZONE_ABBR:
15841           case TIMEZONE_MINUTE:
15842           case TIMEZONE_HOUR:
15843           case TRANSACTION:
15844           case TRUE:
15845           case TYPE:
15846           case UNDER:
15847           case USING:
15848           case YES:
15849           case SHOW:
15850           case A:
15851           case VARCHAR:
15852           case VARCHAR2:
15853           case DOUBLE:
15854           case DEC:
15855           case PRECISION:
15856           case INT:
15857           case NUMERIC:
15858           case SIGNTYPE:
15859           case NCHAR:
15860           case NVARCHAR2:
15861           case STRING:
15862           case UROWID:
15863           case BFILE:
15864           case BLOB:
15865           case CLOB:
15866           case NCLOB:
15867           case YEAR:
15868           case LOCAL:
15869           case ZONE:
15870           case CHARACTER:
15871           case AFTER:
15872           case BEFORE:
15873           case OLD:
15874           case PARENT:
15875           case CC_IF:
15876           case ANALYZE:
15877           case ASSOCIATE:
15878           case AUDIT:
15879           case COMPOUND:
15880           case DATABASE:
15881           case CALL:
15882           case DDL:
15883           case DISASSOCIATE:
15884           case EACH:
15885           case FOLLOWS:
15886           case LOGOFF:
15887           case LOGON:
15888           case NESTED:
15889           case NOAUDIT:
15890           case SCHEMA:
15891           case SERVERERROR:
15892           case SHUTDOWN:
15893           case STARTUP:
15894           case STATEMENT:
15895           case STATISTICS:
15896           case SUSPEND:
15897           case TRUNCATE:
15898           case WRAPPED:
15899           case LIBRARY:
15900           case NAME:
15901           case STRUCT:
15902           case CONTEXT:
15903           case PARAMETERS:
15904           case LENGTH:
15905           case TDO:
15906           case MAXLEN:
15907           case CHARSETID:
15908           case CHARSETFORM:
15909           case ACCEPT:
15910           case ACCESSIBLE:
15911           case COPY:
15912           case DEFINE:
15913           case DISCONNECT:
15914           case HOST:
15915           case PRINT:
15916           case QUIT:
15917           case REMARK:
15918           case UNDEFINE:
15919           case VARIABLE:
15920           case WHENEVER:
15921           case ATTACH:
15922           case CAST:
15923           case TREAT:
15924           case TRIM:
15925           case LEFT:
15926           case RIGHT:
15927           case BOTH:
15928           case EMPTY:
15929           case MULTISET:
15930           case SUBMULTISET:
15931           case LEADING:
15932           case TRAILING:
15933           case CHAR_CS:
15934           case NCHAR_CS:
15935           case DBTIMEZONE:
15936           case SESSIONTIMEZONE:
15937           case AUTHENTICATED:
15938           case LINK:
15939           case SHARED:
15940           case DIRECTORY:
15941           case USER:
15942           case IDENTIFIER:
15943           case QUOTED_LITERAL:
15944             Datatype();
15945             break;
15946           default:
15947             jj_la1[190] = jj_gen;
15948             jj_consume_token(-1);
15949             throw new ParseException();
15950           }
15951         }
15952         break;
15953       default:
15954         jj_la1[191] = jj_gen;
15955         jj_consume_token(-1);
15956         throw new ParseException();
15957       }
15958       jj_consume_token(4);
15959         jjtree.closeNodeScope(jjtn000, true);
15960         jjtc000 = false;
15961         jjtn000.setImage(name.getImage()) ;  {if (true) return jjtn000 ;}
15962     } catch (Throwable jjte000) {
15963           if (jjtc000) {
15964             jjtree.clearNodeScope(jjtn000);
15965             jjtc000 = false;
15966           } else {
15967             jjtree.popNode();
15968           }
15969           if (jjte000 instanceof RuntimeException) {
15970             {if (true) throw (RuntimeException)jjte000;}
15971           }
15972           if (jjte000 instanceof ParseException) {
15973             {if (true) throw (ParseException)jjte000;}
15974           }
15975           {if (true) throw (Error)jjte000;}
15976     } finally {
15977           if (jjtc000) {
15978             jjtree.closeNodeScope(jjtn000, true);
15979           }
15980     }
15981     throw new Error("Missing return statement in function");
15982   }
15983 
15984   final public ASTFieldDeclaration FieldDeclaration() throws ParseException {
15985  /*@bgen(jjtree) FieldDeclaration */
15986         ASTFieldDeclaration jjtn000 = new ASTFieldDeclaration(this, JJTFIELDDECLARATION);
15987         boolean jjtc000 = true;
15988         jjtree.openNodeScope(jjtn000);PLSQLNode name;
15989         PLSQLNode dataType;
15990         PLSQLNode defaultValue = null;
15991     try {
15992       name = ID();
15993       Datatype();
15994       switch (jj_nt.kind) {
15995       case NOT:
15996       case NULL:
15997         switch (jj_nt.kind) {
15998         case NOT:
15999           jj_consume_token(NOT);
16000           break;
16001         default:
16002           jj_la1[192] = jj_gen;
16003           ;
16004         }
16005         jj_consume_token(NULL);
16006         break;
16007       default:
16008         jj_la1[193] = jj_gen;
16009         ;
16010       }
16011       switch (jj_nt.kind) {
16012       case 9:
16013       case _DEFAULT:
16014         switch (jj_nt.kind) {
16015         case 9:
16016           jj_consume_token(9);
16017           jj_consume_token(10);
16018           break;
16019         case _DEFAULT:
16020           jj_consume_token(_DEFAULT);
16021           break;
16022         default:
16023           jj_la1[194] = jj_gen;
16024           jj_consume_token(-1);
16025           throw new ParseException();
16026         }
16027         Expression();
16028         break;
16029       default:
16030         jj_la1[195] = jj_gen;
16031         ;
16032       }
16033         jjtree.closeNodeScope(jjtn000, true);
16034         jjtc000 = false;
16035         jjtn000.setImage(name.getImage()) ;  {if (true) return jjtn000 ;}
16036     } catch (Throwable jjte000) {
16037           if (jjtc000) {
16038             jjtree.clearNodeScope(jjtn000);
16039             jjtc000 = false;
16040           } else {
16041             jjtree.popNode();
16042           }
16043           if (jjte000 instanceof RuntimeException) {
16044             {if (true) throw (RuntimeException)jjte000;}
16045           }
16046           if (jjte000 instanceof ParseException) {
16047             {if (true) throw (ParseException)jjte000;}
16048           }
16049           {if (true) throw (Error)jjte000;}
16050     } finally {
16051           if (jjtc000) {
16052             jjtree.closeNodeScope(jjtn000, true);
16053           }
16054     }
16055     throw new Error("Missing return statement in function");
16056   }
16057 
16058   final public ASTCollectionTypeDefinition CollectionTypeDefinition() throws ParseException {
16059                                                           /*@bgen(jjtree) CollectionTypeDefinition */
16060                                                           ASTCollectionTypeDefinition jjtn000 = new ASTCollectionTypeDefinition(this, JJTCOLLECTIONTYPEDEFINITION);
16061                                                           boolean jjtc000 = true;
16062                                                           jjtree.openNodeScope(jjtn000);Token t = null ;
16063     try {
16064       t = jj_consume_token(IDENTIFIER);
16065                                                                                                   jjtree.closeNodeScope(jjtn000, true);
16066                                                                                                   jjtc000 = false;
16067                                                                                                   jjtn000.setImage(t.image) ;  {if (true) return jjtn000 ;}
16068     } finally {
16069                                                                                  if (jjtc000) {
16070                                                                                    jjtree.closeNodeScope(jjtn000, true);
16071                                                                                  }
16072     }
16073     throw new Error("Missing return statement in function");
16074   }
16075 
16076   final public ASTCollectionDeclaration CollectionDeclaration() throws ParseException {
16077                                                     /*@bgen(jjtree) CollectionDeclaration */
16078                                                     ASTCollectionDeclaration jjtn000 = new ASTCollectionDeclaration(this, JJTCOLLECTIONDECLARATION);
16079                                                     boolean jjtc000 = true;
16080                                                     jjtree.openNodeScope(jjtn000);Token t = null ;
16081     try {
16082       t = jj_consume_token(IDENTIFIER);
16083                                                                                             jjtree.closeNodeScope(jjtn000, true);
16084                                                                                             jjtc000 = false;
16085                                                                                             jjtn000.setImage(t.image) ;  {if (true) return jjtn000 ;}
16086     } finally {
16087                                                                            if (jjtc000) {
16088                                                                              jjtree.closeNodeScope(jjtn000, true);
16089                                                                            }
16090     }
16091     throw new Error("Missing return statement in function");
16092   }
16093 
16094   final public ASTObjectDeclaration ObjectDeclaration() throws ParseException {
16095                                             /*@bgen(jjtree) ObjectDeclaration */
16096                                             ASTObjectDeclaration jjtn000 = new ASTObjectDeclaration(this, JJTOBJECTDECLARATION);
16097                                             boolean jjtc000 = true;
16098                                             jjtree.openNodeScope(jjtn000);Token t = null ;
16099     try {
16100       t = jj_consume_token(IDENTIFIER);
16101                                                                                     jjtree.closeNodeScope(jjtn000, true);
16102                                                                                     jjtc000 = false;
16103                                                                                     jjtn000.setImage(t.image) ;  {if (true) return jjtn000 ;}
16104     } finally {
16105                                                                    if (jjtc000) {
16106                                                                      jjtree.closeNodeScope(jjtn000, true);
16107                                                                    }
16108     }
16109     throw new Error("Missing return statement in function");
16110   }
16111 
16112 /** Java stored procedure, external function*/
16113   final public ASTCallSpecTail CallSpecTail() throws ParseException {
16114                                   /*@bgen(jjtree) CallSpecTail */
16115   ASTCallSpecTail jjtn000 = new ASTCallSpecTail(this, JJTCALLSPECTAIL);
16116   boolean jjtc000 = true;
16117   jjtree.openNodeScope(jjtn000);
16118     try {
16119       switch (jj_nt.kind) {
16120       case EXTERNAL:
16121         jj_consume_token(EXTERNAL);
16122         break;
16123       case LANGUAGE:
16124         jj_consume_token(LANGUAGE);
16125         switch (jj_nt.kind) {
16126         case IDENTIFIER:
16127           jj_consume_token(IDENTIFIER);
16128           break;
16129         case JAVA:
16130           jj_consume_token(JAVA);
16131           break;
16132         default:
16133           jj_la1[196] = jj_gen;
16134           jj_consume_token(-1);
16135           throw new ParseException();
16136         }
16137         break;
16138       default:
16139         jj_la1[197] = jj_gen;
16140         jj_consume_token(-1);
16141         throw new ParseException();
16142       }
16143       label_47:
16144       while (true) {
16145         switch (jj_nt.kind) {
16146         case WITH:
16147         case LIBRARY:
16148         case NAME:
16149         case PARAMETERS:
16150           ;
16151           break;
16152         default:
16153           jj_la1[198] = jj_gen;
16154           break label_47;
16155         }
16156         switch (jj_nt.kind) {
16157         case LIBRARY:
16158           jj_consume_token(LIBRARY);
16159           switch (jj_nt.kind) {
16160           case IDENTIFIER:
16161             jj_consume_token(IDENTIFIER);
16162             break;
16163           case QUOTED_LITERAL:
16164             jj_consume_token(QUOTED_LITERAL);
16165             break;
16166           case STRING_LITERAL:
16167             StringLiteral();
16168             break;
16169           default:
16170             jj_la1[199] = jj_gen;
16171             jj_consume_token(-1);
16172             throw new ParseException();
16173           }
16174           switch (jj_nt.kind) {
16175           case 3:
16176             jj_consume_token(3);
16177             switch (jj_nt.kind) {
16178             case IDENTIFIER:
16179               jj_consume_token(IDENTIFIER);
16180               break;
16181             case QUOTED_LITERAL:
16182               jj_consume_token(QUOTED_LITERAL);
16183               break;
16184             case STRING_LITERAL:
16185               StringLiteral();
16186               break;
16187             default:
16188               jj_la1[200] = jj_gen;
16189               jj_consume_token(-1);
16190               throw new ParseException();
16191             }
16192             break;
16193           default:
16194             jj_la1[201] = jj_gen;
16195             ;
16196           }
16197           break;
16198         case NAME:
16199           jj_consume_token(NAME);
16200           switch (jj_nt.kind) {
16201           case IDENTIFIER:
16202             jj_consume_token(IDENTIFIER);
16203             break;
16204           case QUOTED_LITERAL:
16205             jj_consume_token(QUOTED_LITERAL);
16206             break;
16207           case STRING_LITERAL:
16208             StringLiteral();
16209             break;
16210           default:
16211             jj_la1[202] = jj_gen;
16212             jj_consume_token(-1);
16213             throw new ParseException();
16214           }
16215           break;
16216         case WITH:
16217           jj_consume_token(WITH);
16218           jj_consume_token(CONTEXT);
16219           break;
16220         case PARAMETERS:
16221           jj_consume_token(PARAMETERS);
16222           SkipPastNextOccurrence(")");
16223           break;
16224         default:
16225           jj_la1[203] = jj_gen;
16226           jj_consume_token(-1);
16227           throw new ParseException();
16228         }
16229       }
16230         jjtree.closeNodeScope(jjtn000, true);
16231         jjtc000 = false;
16232         {if (true) return jjtn000 ;}
16233     } catch (Throwable jjte000) {
16234           if (jjtc000) {
16235             jjtree.clearNodeScope(jjtn000);
16236             jjtc000 = false;
16237           } else {
16238             jjtree.popNode();
16239           }
16240           if (jjte000 instanceof RuntimeException) {
16241             {if (true) throw (RuntimeException)jjte000;}
16242           }
16243           if (jjte000 instanceof ParseException) {
16244             {if (true) throw (ParseException)jjte000;}
16245           }
16246           {if (true) throw (Error)jjte000;}
16247     } finally {
16248           if (jjtc000) {
16249             jjtree.closeNodeScope(jjtn000, true);
16250           }
16251     }
16252     throw new Error("Missing return statement in function");
16253   }
16254 
16255 /** Cursor (common part of specification and body) */
16256   final public ASTCursorUnit CursorUnit() throws ParseException {
16257  /*@bgen(jjtree) CursorUnit */
16258  ASTCursorUnit jjtn000 = new ASTCursorUnit(this, JJTCURSORUNIT);
16259  boolean jjtc000 = true;
16260  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
16261     try {
16262       jj_consume_token(CURSOR);
16263       simpleNode = ID();
16264       switch (jj_nt.kind) {
16265       case 5:
16266         FormalParameters();
16267         break;
16268       default:
16269         jj_la1[204] = jj_gen;
16270         ;
16271       }
16272       switch (jj_nt.kind) {
16273       case RETURN:
16274         jj_consume_token(RETURN);
16275         Datatype();
16276         break;
16277       default:
16278         jj_la1[205] = jj_gen;
16279         ;
16280       }
16281       switch (jj_nt.kind) {
16282       case IS:
16283         jj_consume_token(IS);
16284         label_48:
16285         while (true) {
16286           switch (jj_nt.kind) {
16287           case 5:
16288             ;
16289             break;
16290           default:
16291             jj_la1[206] = jj_gen;
16292             break label_48;
16293           }
16294           jj_consume_token(5);
16295         }
16296         SqlStatement(null,";");
16297         break;
16298       default:
16299         jj_la1[207] = jj_gen;
16300         ;
16301       }
16302       jj_consume_token(4);
16303         jjtree.closeNodeScope(jjtn000, true);
16304         jjtc000 = false;
16305         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
16306     } catch (Throwable jjte000) {
16307           if (jjtc000) {
16308             jjtree.clearNodeScope(jjtn000);
16309             jjtc000 = false;
16310           } else {
16311             jjtree.popNode();
16312           }
16313           if (jjte000 instanceof RuntimeException) {
16314             {if (true) throw (RuntimeException)jjte000;}
16315           }
16316           if (jjte000 instanceof ParseException) {
16317             {if (true) throw (ParseException)jjte000;}
16318           }
16319           {if (true) throw (Error)jjte000;}
16320     } finally {
16321           if (jjtc000) {
16322             jjtree.closeNodeScope(jjtn000, true);
16323           }
16324     }
16325     throw new Error("Missing return statement in function");
16326   }
16327 
16328   final public ASTCursorSpecification CursorSpecification() throws ParseException {
16329                                                  /*@bgen(jjtree) CursorSpecification */
16330   ASTCursorSpecification jjtn000 = new ASTCursorSpecification(this, JJTCURSORSPECIFICATION);
16331   boolean jjtc000 = true;
16332   jjtree.openNodeScope(jjtn000);
16333     try {
16334       CursorUnit();
16335         jjtree.closeNodeScope(jjtn000, true);
16336         jjtc000 = false;
16337         {if (true) return jjtn000 ;}
16338     } catch (Throwable jjte000) {
16339           if (jjtc000) {
16340             jjtree.clearNodeScope(jjtn000);
16341             jjtc000 = false;
16342           } else {
16343             jjtree.popNode();
16344           }
16345           if (jjte000 instanceof RuntimeException) {
16346             {if (true) throw (RuntimeException)jjte000;}
16347           }
16348           if (jjte000 instanceof ParseException) {
16349             {if (true) throw (ParseException)jjte000;}
16350           }
16351           {if (true) throw (Error)jjte000;}
16352     } finally {
16353           if (jjtc000) {
16354             jjtree.closeNodeScope(jjtn000, true);
16355           }
16356     }
16357     throw new Error("Missing return statement in function");
16358   }
16359 
16360   final public ASTCursorBody CursorBody() throws ParseException {
16361                                /*@bgen(jjtree) CursorBody */
16362   ASTCursorBody jjtn000 = new ASTCursorBody(this, JJTCURSORBODY);
16363   boolean jjtc000 = true;
16364   jjtree.openNodeScope(jjtn000);
16365     try {
16366       CursorUnit();
16367         jjtree.closeNodeScope(jjtn000, true);
16368         jjtc000 = false;
16369         {if (true) return jjtn000 ;}
16370     } catch (Throwable jjte000) {
16371           if (jjtc000) {
16372             jjtree.clearNodeScope(jjtn000);
16373             jjtc000 = false;
16374           } else {
16375             jjtree.popNode();
16376           }
16377           if (jjte000 instanceof RuntimeException) {
16378             {if (true) throw (RuntimeException)jjte000;}
16379           }
16380           if (jjte000 instanceof ParseException) {
16381             {if (true) throw (ParseException)jjte000;}
16382           }
16383           {if (true) throw (Error)jjte000;}
16384     } finally {
16385           if (jjtc000) {
16386             jjtree.closeNodeScope(jjtn000, true);
16387           }
16388     }
16389     throw new Error("Missing return statement in function");
16390   }
16391 
16392 // ============================================================================
16393 // E X P R E S S I O N S
16394 // ============================================================================
16395 
16396 /*
16397 String expression() :
16398 {}
16399 {
16400 	"test"
16401 	{ return ""; }
16402 }
16403 */
16404   final public ASTExpression Expression() throws ParseException {
16405  /*@bgen(jjtree) Expression */
16406   ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
16407   boolean jjtc000 = true;
16408   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
16409   StringBuilder sb = new StringBuilder() ;
16410     try {
16411       if (jj_2_45(2147483647)) {
16412         simpleNode = Assignment();
16413                                                                               sb.append(simpleNode.getImage());
16414       } else {
16415         switch (jj_nt.kind) {
16416         case 5:
16417         case 16:
16418         case 17:
16419         case REPLACE:
16420         case DEFINER:
16421         case CURRENT_USER:
16422         case LANGUAGE:
16423         case ADD:
16424         case AGGREGATE:
16425         case ARRAY:
16426         case AT:
16427         case ATTRIBUTE:
16428         case AUTHID:
16429         case BODY:
16430         case BULK:
16431         case BYTE:
16432         case CASCADE:
16433         case CASE:
16434         case CLOSE:
16435         case COALESCE:
16436         case COLLECT:
16437         case COLUMN:
16438         case COMMENT:
16439         case COMMIT:
16440         case CONSTRUCTOR:
16441         case CONTINUE:
16442         case CONVERT:
16443         case CURRENT:
16444         case CURSOR:
16445         case DATA:
16446         case DATE:
16447         case DAY:
16448         case DISABLE:
16449         case EDITIONABLE:
16450         case ELEMENT:
16451         case ENABLE:
16452         case ESCAPE:
16453         case EXCEPT:
16454         case EXCEPTIONS:
16455         case EXIT:
16456         case EXTERNAL:
16457         case EXTENDS:
16458         case EXTRACT:
16459         case FALSE:
16460         case FINAL:
16461         case FORCE:
16462         case FUNCTION:
16463         case GLOBAL:
16464         case HASH:
16465         case HEAP:
16466         case HOUR:
16467         case IMMEDIATE:
16468         case INDICES:
16469         case INDEXTYPE:
16470         case INDICATOR:
16471         case INSTANTIABLE:
16472         case INTERVAL:
16473         case INVALIDATE:
16474         case ISOLATION:
16475         case JAVA:
16476         case LEVEL:
16477         case LIMIT:
16478         case LOOP:
16479         case MAP:
16480         case MAX:
16481         case MEMBER:
16482         case MERGE:
16483         case MIN:
16484         case MINUTE:
16485         case MLSLABEL:
16486         case MODIFY:
16487         case MOD:
16488         case MONTH:
16489         case NATURAL:
16490         case NEW:
16491         case NEW_DOT:
16492         case NO:
16493         case NONEDITIONABLE:
16494         case NOT:
16495         case NULL:
16496         case NULLIF:
16497         case OBJECT:
16498         case OID:
16499         case OPAQUE:
16500         case OPEN:
16501         case OPERATOR:
16502         case ORGANIZATION:
16503         case OTHERS:
16504         case OVERRIDING:
16505         case PACKAGE:
16506         case PARTITION:
16507         case PRESERVE:
16508         case PRIVATE:
16509         case PROCEDURE:
16510         case RANGE:
16511         case RAW:
16512         case REAL:
16513         case RECORD:
16514         case REF:
16515         case RELEASE:
16516         case RELIES_ON:
16517         case RENAME:
16518         case RESULT:
16519         case RETURN:
16520         case RETURNING:
16521         case REVERSE:
16522         case ROLLBACK:
16523         case ROW:
16524         case ROWS:
16525         case ROWID:
16526         case ROWNUM:
16527         case SAVE:
16528         case SAVEPOINT:
16529         case SECOND:
16530         case SELECT:
16531         case SELF:
16532         case SET:
16533         case SPACE:
16534         case SQL:
16535         case SQLCODE:
16536         case SQLERRM:
16537         case STATIC:
16538         case SUBTYPE:
16539         case SUBSTITUTABLE:
16540         case SUCCESSFUL:
16541         case SYSDATE:
16542         case SYS_REFCURSOR:
16543         case TEMPORARY:
16544         case TIME:
16545         case TIMESTAMP:
16546         case TIMEZONE_REGION:
16547         case TIMEZONE_ABBR:
16548         case TIMEZONE_MINUTE:
16549         case TIMEZONE_HOUR:
16550         case TRANSACTION:
16551         case TRUE:
16552         case TYPE:
16553         case UNDER:
16554         case USING:
16555         case YES:
16556         case SHOW:
16557         case A:
16558         case DOUBLE:
16559         case DEC:
16560         case PRECISION:
16561         case INT:
16562         case NUMERIC:
16563         case NCHAR:
16564         case NVARCHAR2:
16565         case STRING:
16566         case UROWID:
16567         case VARRAY:
16568         case VARYING:
16569         case BFILE:
16570         case BLOB:
16571         case CLOB:
16572         case NCLOB:
16573         case YEAR:
16574         case LOCAL:
16575         case WITH:
16576         case ZONE:
16577         case CHARACTER:
16578         case AFTER:
16579         case BEFORE:
16580         case OLD:
16581         case PARENT:
16582         case ANALYZE:
16583         case ASSOCIATE:
16584         case AUDIT:
16585         case COMPOUND:
16586         case DATABASE:
16587         case CALL:
16588         case DDL:
16589         case DISASSOCIATE:
16590         case EACH:
16591         case FOLLOWS:
16592         case LOGOFF:
16593         case LOGON:
16594         case NESTED:
16595         case NOAUDIT:
16596         case SCHEMA:
16597         case SERVERERROR:
16598         case SHUTDOWN:
16599         case STARTUP:
16600         case STATEMENT:
16601         case STATISTICS:
16602         case SUSPEND:
16603         case TRUNCATE:
16604         case WRAPPED:
16605         case LIBRARY:
16606         case NAME:
16607         case STRUCT:
16608         case CONTEXT:
16609         case PARAMETERS:
16610         case LENGTH:
16611         case TDO:
16612         case MAXLEN:
16613         case CHARSETID:
16614         case CHARSETFORM:
16615         case ACCEPT:
16616         case ACCESSIBLE:
16617         case COPY:
16618         case DEFINE:
16619         case DISCONNECT:
16620         case HOST:
16621         case PRINT:
16622         case QUIT:
16623         case REMARK:
16624         case UNDEFINE:
16625         case VARIABLE:
16626         case WHENEVER:
16627         case ATTACH:
16628         case CAST:
16629         case TREAT:
16630         case TRIM:
16631         case LEFT:
16632         case RIGHT:
16633         case BOTH:
16634         case EMPTY:
16635         case MULTISET:
16636         case SUBMULTISET:
16637         case LEADING:
16638         case TRAILING:
16639         case CHAR_CS:
16640         case NCHAR_CS:
16641         case DBTIMEZONE:
16642         case SESSIONTIMEZONE:
16643         case AUTHENTICATED:
16644         case LINK:
16645         case SHARED:
16646         case DIRECTORY:
16647         case USER:
16648         case IDENTIFIER:
16649         case UNSIGNED_NUMERIC_LITERAL:
16650         case CHARACTER_LITERAL:
16651         case STRING_LITERAL:
16652         case QUOTED_LITERAL:
16653           simpleNode = ConditionalOrExpression();
16654                                                       sb.append(simpleNode.getImage());
16655           break;
16656         case CC_IF:
16657           simpleNode = CompilationExpression();
16658                                                     sb.append(simpleNode.getImage());
16659           break;
16660         default:
16661           jj_la1[208] = jj_gen;
16662           jj_consume_token(-1);
16663           throw new ParseException();
16664         }
16665       }
16666    jjtree.closeNodeScope(jjtn000, true);
16667    jjtc000 = false;
16668  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16669     } catch (Throwable jjte000) {
16670           if (jjtc000) {
16671             jjtree.clearNodeScope(jjtn000);
16672             jjtc000 = false;
16673           } else {
16674             jjtree.popNode();
16675           }
16676           if (jjte000 instanceof RuntimeException) {
16677             {if (true) throw (RuntimeException)jjte000;}
16678           }
16679           if (jjte000 instanceof ParseException) {
16680             {if (true) throw (ParseException)jjte000;}
16681           }
16682           {if (true) throw (Error)jjte000;}
16683     } finally {
16684           if (jjtc000) {
16685             jjtree.closeNodeScope(jjtn000, true);
16686           }
16687     }
16688     throw new Error("Missing return statement in function");
16689   }
16690 
16691   final public ASTCompilationExpression CompilationExpression() throws ParseException {
16692  /*@bgen(jjtree) CompilationExpression */
16693   ASTCompilationExpression jjtn000 = new ASTCompilationExpression(this, JJTCOMPILATIONEXPRESSION);
16694   boolean jjtc000 = true;
16695   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
16696   StringBuilder sb = new StringBuilder() ;
16697     try {
16698       jj_consume_token(CC_IF);
16699                    sb.append(" "); sb.append(token.image) ;
16700       simpleNode = ConditionalOrExpression();
16701                                                    sb.append(" "); sb.append(simpleNode.getImage());
16702       jj_consume_token(CC_THEN);
16703                      sb.append(" "); sb.append(token.image);
16704       simpleNode = Expression();
16705                                      sb.append(" "); sb.append(simpleNode.getImage());
16706       label_49:
16707       while (true) {
16708         switch (jj_nt.kind) {
16709         case CC_ELSIF:
16710           ;
16711           break;
16712         default:
16713           jj_la1[209] = jj_gen;
16714           break label_49;
16715         }
16716         jj_consume_token(CC_ELSIF);
16717                         sb.append(" "); sb.append(token.image);
16718         simpleNode = ConditionalOrExpression();
16719                                                     sb.append(" "); sb.append(simpleNode.getImage());
16720         jj_consume_token(CC_THEN);
16721                        sb.append(" "); sb.append(token.image);
16722         simpleNode = Expression();
16723                                        sb.append(" "); sb.append(simpleNode.getImage());
16724       }
16725       label_50:
16726       while (true) {
16727         switch (jj_nt.kind) {
16728         case CC_ELSE:
16729           ;
16730           break;
16731         default:
16732           jj_la1[210] = jj_gen;
16733           break label_50;
16734         }
16735         jj_consume_token(CC_ELSE);
16736                        sb.append(" "); sb.append(token.image);
16737         simpleNode = Expression();
16738                                         sb.append(" "); sb.append(simpleNode.getImage());
16739       }
16740       jj_consume_token(CC_END);
16741                     sb.append(" "); sb.append(token.image);
16742    jjtree.closeNodeScope(jjtn000, true);
16743    jjtc000 = false;
16744  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16745     } catch (Throwable jjte000) {
16746           if (jjtc000) {
16747             jjtree.clearNodeScope(jjtn000);
16748             jjtc000 = false;
16749           } else {
16750             jjtree.popNode();
16751           }
16752           if (jjte000 instanceof RuntimeException) {
16753             {if (true) throw (RuntimeException)jjte000;}
16754           }
16755           if (jjte000 instanceof ParseException) {
16756             {if (true) throw (ParseException)jjte000;}
16757           }
16758           {if (true) throw (Error)jjte000;}
16759     } finally {
16760           if (jjtc000) {
16761             jjtree.closeNodeScope(jjtn000, true);
16762           }
16763     }
16764     throw new Error("Missing return statement in function");
16765   }
16766 
16767   final public ASTAssignment Assignment() throws ParseException {
16768  /*@bgen(jjtree) Assignment */
16769   ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT);
16770   boolean jjtc000 = true;
16771   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
16772     try {
16773       simpleNode = PrimaryExpression();
16774                                        sb.append(simpleNode.getImage());
16775       jj_consume_token(9);
16776       jj_consume_token(10);
16777                sb.append(" := ");
16778       simpleNode = Expression();
16779                                sb.append(simpleNode.getImage());
16780    jjtree.closeNodeScope(jjtn000, true);
16781    jjtc000 = false;
16782  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16783     } catch (Throwable jjte000) {
16784     if (jjtc000) {
16785       jjtree.clearNodeScope(jjtn000);
16786       jjtc000 = false;
16787     } else {
16788       jjtree.popNode();
16789     }
16790     if (jjte000 instanceof RuntimeException) {
16791       {if (true) throw (RuntimeException)jjte000;}
16792     }
16793     if (jjte000 instanceof ParseException) {
16794       {if (true) throw (ParseException)jjte000;}
16795     }
16796     {if (true) throw (Error)jjte000;}
16797     } finally {
16798     if (jjtc000) {
16799       jjtree.closeNodeScope(jjtn000, true);
16800     }
16801     }
16802     throw new Error("Missing return statement in function");
16803   }
16804 
16805   final public ASTCaseExpression CaseExpression() throws ParseException {
16806  /*@bgen(jjtree) CaseExpression */
16807   ASTCaseExpression jjtn000 = new ASTCaseExpression(this, JJTCASEEXPRESSION);
16808   boolean jjtc000 = true;
16809   jjtree.openNodeScope(jjtn000);Token thisToken;  PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
16810     try {
16811       thisToken = jj_consume_token(CASE);
16812                              sb.append(thisToken.image);
16813       switch (jj_nt.kind) {
16814       case 5:
16815       case 16:
16816       case 17:
16817       case REPLACE:
16818       case DEFINER:
16819       case CURRENT_USER:
16820       case LANGUAGE:
16821       case ADD:
16822       case AGGREGATE:
16823       case ARRAY:
16824       case AT:
16825       case ATTRIBUTE:
16826       case AUTHID:
16827       case BODY:
16828       case BULK:
16829       case BYTE:
16830       case CASCADE:
16831       case CASE:
16832       case CLOSE:
16833       case COALESCE:
16834       case COLLECT:
16835       case COLUMN:
16836       case COMMENT:
16837       case COMMIT:
16838       case CONSTRUCTOR:
16839       case CONTINUE:
16840       case CONVERT:
16841       case CURRENT:
16842       case CURSOR:
16843       case DATA:
16844       case DATE:
16845       case DAY:
16846       case DISABLE:
16847       case EDITIONABLE:
16848       case ELEMENT:
16849       case ENABLE:
16850       case ESCAPE:
16851       case EXCEPT:
16852       case EXCEPTIONS:
16853       case EXIT:
16854       case EXTERNAL:
16855       case EXTENDS:
16856       case EXTRACT:
16857       case FALSE:
16858       case FINAL:
16859       case FORCE:
16860       case FUNCTION:
16861       case GLOBAL:
16862       case HASH:
16863       case HEAP:
16864       case HOUR:
16865       case IMMEDIATE:
16866       case INDICES:
16867       case INDEXTYPE:
16868       case INDICATOR:
16869       case INSTANTIABLE:
16870       case INTERVAL:
16871       case INVALIDATE:
16872       case ISOLATION:
16873       case JAVA:
16874       case LEVEL:
16875       case LIMIT:
16876       case LOOP:
16877       case MAP:
16878       case MAX:
16879       case MEMBER:
16880       case MERGE:
16881       case MIN:
16882       case MINUTE:
16883       case MLSLABEL:
16884       case MODIFY:
16885       case MOD:
16886       case MONTH:
16887       case NATURAL:
16888       case NEW:
16889       case NEW_DOT:
16890       case NO:
16891       case NONEDITIONABLE:
16892       case NOT:
16893       case NULL:
16894       case NULLIF:
16895       case OBJECT:
16896       case OID:
16897       case OPAQUE:
16898       case OPEN:
16899       case OPERATOR:
16900       case ORGANIZATION:
16901       case OTHERS:
16902       case OVERRIDING:
16903       case PACKAGE:
16904       case PARTITION:
16905       case PRESERVE:
16906       case PRIVATE:
16907       case PROCEDURE:
16908       case RANGE:
16909       case RAW:
16910       case REAL:
16911       case RECORD:
16912       case REF:
16913       case RELEASE:
16914       case RELIES_ON:
16915       case RENAME:
16916       case RESULT:
16917       case RETURN:
16918       case RETURNING:
16919       case REVERSE:
16920       case ROLLBACK:
16921       case ROW:
16922       case ROWS:
16923       case ROWID:
16924       case ROWNUM:
16925       case SAVE:
16926       case SAVEPOINT:
16927       case SECOND:
16928       case SELECT:
16929       case SELF:
16930       case SET:
16931       case SPACE:
16932       case SQL:
16933       case SQLCODE:
16934       case SQLERRM:
16935       case STATIC:
16936       case SUBTYPE:
16937       case SUBSTITUTABLE:
16938       case SUCCESSFUL:
16939       case SYSDATE:
16940       case SYS_REFCURSOR:
16941       case TEMPORARY:
16942       case TIME:
16943       case TIMESTAMP:
16944       case TIMEZONE_REGION:
16945       case TIMEZONE_ABBR:
16946       case TIMEZONE_MINUTE:
16947       case TIMEZONE_HOUR:
16948       case TRANSACTION:
16949       case TRUE:
16950       case TYPE:
16951       case UNDER:
16952       case USING:
16953       case YES:
16954       case SHOW:
16955       case A:
16956       case DOUBLE:
16957       case DEC:
16958       case PRECISION:
16959       case INT:
16960       case NUMERIC:
16961       case NCHAR:
16962       case NVARCHAR2:
16963       case STRING:
16964       case UROWID:
16965       case VARRAY:
16966       case VARYING:
16967       case BFILE:
16968       case BLOB:
16969       case CLOB:
16970       case NCLOB:
16971       case YEAR:
16972       case LOCAL:
16973       case WITH:
16974       case ZONE:
16975       case CHARACTER:
16976       case AFTER:
16977       case BEFORE:
16978       case OLD:
16979       case PARENT:
16980       case CC_IF:
16981       case ANALYZE:
16982       case ASSOCIATE:
16983       case AUDIT:
16984       case COMPOUND:
16985       case DATABASE:
16986       case CALL:
16987       case DDL:
16988       case DISASSOCIATE:
16989       case EACH:
16990       case FOLLOWS:
16991       case LOGOFF:
16992       case LOGON:
16993       case NESTED:
16994       case NOAUDIT:
16995       case SCHEMA:
16996       case SERVERERROR:
16997       case SHUTDOWN:
16998       case STARTUP:
16999       case STATEMENT:
17000       case STATISTICS:
17001       case SUSPEND:
17002       case TRUNCATE:
17003       case WRAPPED:
17004       case LIBRARY:
17005       case NAME:
17006       case STRUCT:
17007       case CONTEXT:
17008       case PARAMETERS:
17009       case LENGTH:
17010       case TDO:
17011       case MAXLEN:
17012       case CHARSETID:
17013       case CHARSETFORM:
17014       case ACCEPT:
17015       case ACCESSIBLE:
17016       case COPY:
17017       case DEFINE:
17018       case DISCONNECT:
17019       case HOST:
17020       case PRINT:
17021       case QUIT:
17022       case REMARK:
17023       case UNDEFINE:
17024       case VARIABLE:
17025       case WHENEVER:
17026       case ATTACH:
17027       case CAST:
17028       case TREAT:
17029       case TRIM:
17030       case LEFT:
17031       case RIGHT:
17032       case BOTH:
17033       case EMPTY:
17034       case MULTISET:
17035       case SUBMULTISET:
17036       case LEADING:
17037       case TRAILING:
17038       case CHAR_CS:
17039       case NCHAR_CS:
17040       case DBTIMEZONE:
17041       case SESSIONTIMEZONE:
17042       case AUTHENTICATED:
17043       case LINK:
17044       case SHARED:
17045       case DIRECTORY:
17046       case USER:
17047       case IDENTIFIER:
17048       case UNSIGNED_NUMERIC_LITERAL:
17049       case CHARACTER_LITERAL:
17050       case STRING_LITERAL:
17051       case QUOTED_LITERAL:
17052         simpleNode = Expression();
17053                                       sb.append(" "); sb.append(simpleNode.getImage());
17054         break;
17055       default:
17056         jj_la1[211] = jj_gen;
17057         ;
17058       }
17059       label_51:
17060       while (true) {
17061         thisToken = jj_consume_token(WHEN);
17062                                  sb.append("  "); sb.append(thisToken.image);
17063         simpleNode = Expression();
17064                                             sb.append(" "); sb.append(simpleNode.getImage());
17065         thisToken = jj_consume_token(THEN);
17066                                    sb.append(" "); sb.append(thisToken.image);
17067         Expression();
17068                                  sb.append(" "); sb.append(simpleNode.getImage());
17069         switch (jj_nt.kind) {
17070         case WHEN:
17071           ;
17072           break;
17073         default:
17074           jj_la1[212] = jj_gen;
17075           break label_51;
17076         }
17077       }
17078       switch (jj_nt.kind) {
17079       case ELSE:
17080         thisToken = jj_consume_token(ELSE);
17081                                  sb.append(" "); sb.append(thisToken.image);
17082         Expression();
17083                                sb.append(" "); sb.append(simpleNode.getImage());
17084         break;
17085       default:
17086         jj_la1[213] = jj_gen;
17087         ;
17088       }
17089       thisToken = jj_consume_token(END);
17090                               sb.append(" "); sb.append(thisToken.image);
17091    jjtree.closeNodeScope(jjtn000, true);
17092    jjtc000 = false;
17093  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17094     } catch (Throwable jjte000) {
17095     if (jjtc000) {
17096       jjtree.clearNodeScope(jjtn000);
17097       jjtc000 = false;
17098     } else {
17099       jjtree.popNode();
17100     }
17101     if (jjte000 instanceof RuntimeException) {
17102       {if (true) throw (RuntimeException)jjte000;}
17103     }
17104     if (jjte000 instanceof ParseException) {
17105       {if (true) throw (ParseException)jjte000;}
17106     }
17107     {if (true) throw (Error)jjte000;}
17108     } finally {
17109     if (jjtc000) {
17110       jjtree.closeNodeScope(jjtn000, true);
17111     }
17112     }
17113     throw new Error("Missing return statement in function");
17114   }
17115 
17116 /*
17117 LIKE ( Expression ) [ <ESCAPE> <STRINGLITERAL>
17118 */
17119   final public ASTLikeExpression LikeExpression() throws ParseException {
17120  /*@bgen(jjtree) LikeExpression */
17121   ASTLikeExpression jjtn000 = new ASTLikeExpression(this, JJTLIKEEXPRESSION);
17122   boolean jjtc000 = true;
17123   jjtree.openNodeScope(jjtn000);Token thisToken;  PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17124     try {
17125       simpleNode = PrimaryExpression();
17126                                            sb.append(" "); sb.append(simpleNode.getImage());
17127       thisToken = jj_consume_token(LIKE);
17128                                 sb.append(thisToken.image);
17129       simpleNode = StringExpression();
17130                                             sb.append(" "); sb.append(simpleNode.getImage());
17131       switch (jj_nt.kind) {
17132       case ESCAPE:
17133         jj_consume_token(ESCAPE);
17134                    sb.append(" ESCAPE ");
17135         switch (jj_nt.kind) {
17136         case CHARACTER_LITERAL:
17137           jj_consume_token(CHARACTER_LITERAL);
17138                                 sb.append(" "); sb.append(token.toString());
17139           break;
17140         case STRING_LITERAL:
17141           simpleNode = StringLiteral();
17142                                            sb.append(" "); sb.append(simpleNode.getImage());
17143           break;
17144         default:
17145           jj_la1[214] = jj_gen;
17146           jj_consume_token(-1);
17147           throw new ParseException();
17148         }
17149         break;
17150       default:
17151         jj_la1[215] = jj_gen;
17152         ;
17153       }
17154       label_52:
17155       while (true) {
17156         switch (jj_nt.kind) {
17157         case 3:
17158           ;
17159           break;
17160         default:
17161           jj_la1[216] = jj_gen;
17162           break label_52;
17163         }
17164         jj_consume_token(3);
17165         simpleNode = Expression();
17166                                     sb.append("."); sb.append(simpleNode.getImage());
17167       }
17168    jjtree.closeNodeScope(jjtn000, true);
17169    jjtc000 = false;
17170  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17171     } catch (Throwable jjte000) {
17172     if (jjtc000) {
17173       jjtree.clearNodeScope(jjtn000);
17174       jjtc000 = false;
17175     } else {
17176       jjtree.popNode();
17177     }
17178     if (jjte000 instanceof RuntimeException) {
17179       {if (true) throw (RuntimeException)jjte000;}
17180     }
17181     if (jjte000 instanceof ParseException) {
17182       {if (true) throw (ParseException)jjte000;}
17183     }
17184     {if (true) throw (Error)jjte000;}
17185     } finally {
17186     if (jjtc000) {
17187       jjtree.closeNodeScope(jjtn000, true);
17188     }
17189     }
17190     throw new Error("Missing return statement in function");
17191   }
17192 
17193   final public ASTTrimExpression TrimExpression() throws ParseException {
17194  /*@bgen(jjtree) TrimExpression */
17195   ASTTrimExpression jjtn000 = new ASTTrimExpression(this, JJTTRIMEXPRESSION);
17196   boolean jjtc000 = true;
17197   jjtree.openNodeScope(jjtn000);Token thisToken;  PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17198     try {
17199       thisToken = jj_consume_token(TRIM);
17200                                 sb.append(thisToken.image);
17201       jj_consume_token(5);
17202               sb.append("(");
17203       switch (jj_nt.kind) {
17204       case BOTH:
17205       case LEADING:
17206       case TRAILING:
17207         switch (jj_nt.kind) {
17208         case LEADING:
17209           jj_consume_token(LEADING);
17210           break;
17211         case TRAILING:
17212           jj_consume_token(TRAILING);
17213           break;
17214         case BOTH:
17215           jj_consume_token(BOTH);
17216           break;
17217         default:
17218           jj_la1[217] = jj_gen;
17219           jj_consume_token(-1);
17220           throw new ParseException();
17221         }
17222                                                 sb.append(" "); sb.append(token.toString());
17223         break;
17224       default:
17225         jj_la1[218] = jj_gen;
17226         ;
17227       }
17228       switch (jj_nt.kind) {
17229       case 5:
17230       case REPLACE:
17231       case DEFINER:
17232       case CURRENT_USER:
17233       case LANGUAGE:
17234       case ADD:
17235       case AGGREGATE:
17236       case ARRAY:
17237       case AT:
17238       case ATTRIBUTE:
17239       case AUTHID:
17240       case BODY:
17241       case BULK:
17242       case BYTE:
17243       case CASCADE:
17244       case CASE:
17245       case CLOSE:
17246       case COALESCE:
17247       case COLLECT:
17248       case COLUMN:
17249       case COMMENT:
17250       case COMMIT:
17251       case CONSTRUCTOR:
17252       case CONTINUE:
17253       case CONVERT:
17254       case CURRENT:
17255       case CURSOR:
17256       case DATA:
17257       case DATE:
17258       case DAY:
17259       case DISABLE:
17260       case EDITIONABLE:
17261       case ELEMENT:
17262       case ENABLE:
17263       case ESCAPE:
17264       case EXCEPT:
17265       case EXCEPTIONS:
17266       case EXIT:
17267       case EXTERNAL:
17268       case EXTENDS:
17269       case EXTRACT:
17270       case FALSE:
17271       case FINAL:
17272       case FORCE:
17273       case FUNCTION:
17274       case GLOBAL:
17275       case HASH:
17276       case HEAP:
17277       case HOUR:
17278       case IMMEDIATE:
17279       case INDICES:
17280       case INDEXTYPE:
17281       case INDICATOR:
17282       case INSTANTIABLE:
17283       case INTERVAL:
17284       case INVALIDATE:
17285       case ISOLATION:
17286       case JAVA:
17287       case LEVEL:
17288       case LIMIT:
17289       case LOOP:
17290       case MAP:
17291       case MAX:
17292       case MEMBER:
17293       case MERGE:
17294       case MIN:
17295       case MINUTE:
17296       case MLSLABEL:
17297       case MODIFY:
17298       case MOD:
17299       case MONTH:
17300       case NATURAL:
17301       case NEW:
17302       case NEW_DOT:
17303       case NO:
17304       case NONEDITIONABLE:
17305       case NULL:
17306       case NULLIF:
17307       case OBJECT:
17308       case OID:
17309       case OPAQUE:
17310       case OPEN:
17311       case OPERATOR:
17312       case ORGANIZATION:
17313       case OTHERS:
17314       case OVERRIDING:
17315       case PACKAGE:
17316       case PARTITION:
17317       case PRESERVE:
17318       case PRIVATE:
17319       case PROCEDURE:
17320       case RANGE:
17321       case RAW:
17322       case REAL:
17323       case RECORD:
17324       case REF:
17325       case RELEASE:
17326       case RELIES_ON:
17327       case RENAME:
17328       case RESULT:
17329       case RETURN:
17330       case RETURNING:
17331       case REVERSE:
17332       case ROLLBACK:
17333       case ROW:
17334       case ROWS:
17335       case ROWID:
17336       case ROWNUM:
17337       case SAVE:
17338       case SAVEPOINT:
17339       case SECOND:
17340       case SELECT:
17341       case SELF:
17342       case SET:
17343       case SPACE:
17344       case SQL:
17345       case SQLCODE:
17346       case SQLERRM:
17347       case STATIC:
17348       case SUBTYPE:
17349       case SUBSTITUTABLE:
17350       case SUCCESSFUL:
17351       case SYSDATE:
17352       case SYS_REFCURSOR:
17353       case TEMPORARY:
17354       case TIME:
17355       case TIMESTAMP:
17356       case TIMEZONE_REGION:
17357       case TIMEZONE_ABBR:
17358       case TIMEZONE_MINUTE:
17359       case TIMEZONE_HOUR:
17360       case TRANSACTION:
17361       case TRUE:
17362       case TYPE:
17363       case UNDER:
17364       case USING:
17365       case YES:
17366       case SHOW:
17367       case A:
17368       case DOUBLE:
17369       case DEC:
17370       case PRECISION:
17371       case INT:
17372       case NUMERIC:
17373       case NCHAR:
17374       case NVARCHAR2:
17375       case STRING:
17376       case UROWID:
17377       case VARRAY:
17378       case VARYING:
17379       case BFILE:
17380       case BLOB:
17381       case CLOB:
17382       case NCLOB:
17383       case YEAR:
17384       case LOCAL:
17385       case WITH:
17386       case ZONE:
17387       case CHARACTER:
17388       case AFTER:
17389       case BEFORE:
17390       case OLD:
17391       case PARENT:
17392       case ANALYZE:
17393       case ASSOCIATE:
17394       case AUDIT:
17395       case COMPOUND:
17396       case DATABASE:
17397       case CALL:
17398       case DDL:
17399       case DISASSOCIATE:
17400       case EACH:
17401       case FOLLOWS:
17402       case LOGOFF:
17403       case LOGON:
17404       case NESTED:
17405       case NOAUDIT:
17406       case SCHEMA:
17407       case SERVERERROR:
17408       case SHUTDOWN:
17409       case STARTUP:
17410       case STATEMENT:
17411       case STATISTICS:
17412       case SUSPEND:
17413       case TRUNCATE:
17414       case WRAPPED:
17415       case LIBRARY:
17416       case NAME:
17417       case STRUCT:
17418       case CONTEXT:
17419       case PARAMETERS:
17420       case LENGTH:
17421       case TDO:
17422       case MAXLEN:
17423       case CHARSETID:
17424       case CHARSETFORM:
17425       case ACCEPT:
17426       case ACCESSIBLE:
17427       case COPY:
17428       case DEFINE:
17429       case DISCONNECT:
17430       case HOST:
17431       case PRINT:
17432       case QUIT:
17433       case REMARK:
17434       case UNDEFINE:
17435       case VARIABLE:
17436       case WHENEVER:
17437       case ATTACH:
17438       case CAST:
17439       case TREAT:
17440       case TRIM:
17441       case LEFT:
17442       case RIGHT:
17443       case BOTH:
17444       case EMPTY:
17445       case MULTISET:
17446       case SUBMULTISET:
17447       case LEADING:
17448       case TRAILING:
17449       case CHAR_CS:
17450       case NCHAR_CS:
17451       case DBTIMEZONE:
17452       case SESSIONTIMEZONE:
17453       case AUTHENTICATED:
17454       case LINK:
17455       case SHARED:
17456       case DIRECTORY:
17457       case USER:
17458       case IDENTIFIER:
17459       case UNSIGNED_NUMERIC_LITERAL:
17460       case CHARACTER_LITERAL:
17461       case STRING_LITERAL:
17462       case QUOTED_LITERAL:
17463         simpleNode = StringExpression();
17464                                              sb.append(" "); sb.append(simpleNode.getImage());
17465         break;
17466       default:
17467         jj_la1[219] = jj_gen;
17468         ;
17469       }
17470       jj_consume_token(FROM);
17471                         sb.append(thisToken.image);
17472       simpleNode = StringExpression();
17473                                            sb.append(" "); sb.append(simpleNode.getImage());
17474       jj_consume_token(7);
17475               sb.append(")");
17476    jjtree.closeNodeScope(jjtn000, true);
17477    jjtc000 = false;
17478  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17479     } catch (Throwable jjte000) {
17480     if (jjtc000) {
17481       jjtree.clearNodeScope(jjtn000);
17482       jjtc000 = false;
17483     } else {
17484       jjtree.popNode();
17485     }
17486     if (jjte000 instanceof RuntimeException) {
17487       {if (true) throw (RuntimeException)jjte000;}
17488     }
17489     if (jjte000 instanceof ParseException) {
17490       {if (true) throw (ParseException)jjte000;}
17491     }
17492     {if (true) throw (Error)jjte000;}
17493     } finally {
17494     if (jjtc000) {
17495       jjtree.closeNodeScope(jjtn000, true);
17496     }
17497     }
17498     throw new Error("Missing return statement in function");
17499   }
17500 
17501 /*
17502 TREAT ( Expression AS datatype)
17503 CAST ( Expression AS datatype)
17504 */
17505   final public ASTObjectExpression ObjectExpression() throws ParseException {
17506  /*@bgen(jjtree) ObjectExpression */
17507   ASTObjectExpression jjtn000 = new ASTObjectExpression(this, JJTOBJECTEXPRESSION);
17508   boolean jjtc000 = true;
17509   jjtree.openNodeScope(jjtn000);Token thisToken;  PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17510     try {
17511       switch (jj_nt.kind) {
17512       case CAST:
17513         thisToken = jj_consume_token(CAST);
17514         break;
17515       case TREAT:
17516         thisToken = jj_consume_token(TREAT);
17517         break;
17518       default:
17519         jj_la1[220] = jj_gen;
17520         jj_consume_token(-1);
17521         throw new ParseException();
17522       }
17523                                                       sb.append(thisToken.image);
17524       jj_consume_token(5);
17525               sb.append("(");
17526       simpleNode = Expression();
17527                                       sb.append(" "); sb.append(simpleNode.getImage());
17528       switch (jj_nt.kind) {
17529       case AT:
17530         jj_consume_token(AT);
17531         jj_consume_token(TIME);
17532         jj_consume_token(ZONE);
17533         simpleNode = PrimaryExpression();
17534                                                                sb.append(" AT TIME ZONE "); sb.append(simpleNode.getImage());
17535         break;
17536       default:
17537         jj_la1[221] = jj_gen;
17538         ;
17539       }
17540       jj_consume_token(AS);
17541                sb.append(" AS ");
17542       simpleNode = Datatype();
17543                                     sb.append(" "); sb.append(simpleNode.getImage());
17544       jj_consume_token(7);
17545               sb.append(")");
17546       label_53:
17547       while (true) {
17548         switch (jj_nt.kind) {
17549         case 3:
17550           ;
17551           break;
17552         default:
17553           jj_la1[222] = jj_gen;
17554           break label_53;
17555         }
17556         jj_consume_token(3);
17557         Expression();
17558       }
17559    jjtree.closeNodeScope(jjtn000, true);
17560    jjtc000 = false;
17561  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17562     } catch (Throwable jjte000) {
17563     if (jjtc000) {
17564       jjtree.clearNodeScope(jjtn000);
17565       jjtc000 = false;
17566     } else {
17567       jjtree.popNode();
17568     }
17569     if (jjte000 instanceof RuntimeException) {
17570       {if (true) throw (RuntimeException)jjte000;}
17571     }
17572     if (jjte000 instanceof ParseException) {
17573       {if (true) throw (ParseException)jjte000;}
17574     }
17575     {if (true) throw (Error)jjte000;}
17576     } finally {
17577     if (jjtc000) {
17578       jjtree.closeNodeScope(jjtn000, true);
17579     }
17580     }
17581     throw new Error("Missing return statement in function");
17582   }
17583 
17584   final public ASTConditionalOrExpression ConditionalOrExpression() throws ParseException {
17585  /*@bgen(jjtree) ConditionalOrExpression */
17586   ASTConditionalOrExpression jjtn000 = new ASTConditionalOrExpression(this, JJTCONDITIONALOREXPRESSION);
17587   boolean jjtc000 = true;
17588   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17589     try {
17590       simpleNode = ConditionalAndExpression();
17591                                                sb.append(simpleNode.getImage());
17592       label_54:
17593       while (true) {
17594         switch (jj_nt.kind) {
17595         case OR:
17596           ;
17597           break;
17598         default:
17599           jj_la1[223] = jj_gen;
17600           break label_54;
17601         }
17602         jj_consume_token(OR);
17603             sb.append(" OR ");
17604         simpleNode = ConditionalAndExpression();
17605                                                 sb.append(simpleNode.getImage());
17606       }
17607    jjtree.closeNodeScope(jjtn000, true);
17608    jjtc000 = false;
17609  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17610     } catch (Throwable jjte000) {
17611     if (jjtc000) {
17612       jjtree.clearNodeScope(jjtn000);
17613       jjtc000 = false;
17614     } else {
17615       jjtree.popNode();
17616     }
17617     if (jjte000 instanceof RuntimeException) {
17618       {if (true) throw (RuntimeException)jjte000;}
17619     }
17620     if (jjte000 instanceof ParseException) {
17621       {if (true) throw (ParseException)jjte000;}
17622     }
17623     {if (true) throw (Error)jjte000;}
17624     } finally {
17625     if (jjtc000) {
17626       jjtree.closeNodeScope(jjtn000, true);
17627     }
17628     }
17629     throw new Error("Missing return statement in function");
17630   }
17631 
17632   final public ASTConditionalAndExpression ConditionalAndExpression() throws ParseException {
17633  /*@bgen(jjtree) ConditionalAndExpression */
17634   ASTConditionalAndExpression jjtn000 = new ASTConditionalAndExpression(this, JJTCONDITIONALANDEXPRESSION);
17635   boolean jjtc000 = true;
17636   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17637     try {
17638       simpleNode = EqualityExpression();
17639                                           sb.append(simpleNode.getImage());
17640       label_55:
17641       while (true) {
17642         switch (jj_nt.kind) {
17643         case AND:
17644           ;
17645           break;
17646         default:
17647           jj_la1[224] = jj_gen;
17648           break label_55;
17649         }
17650         jj_consume_token(AND);
17651                sb.append(" AND ");
17652         simpleNode = EqualityExpression();
17653                                             sb.append(simpleNode.getImage());
17654       }
17655    jjtree.closeNodeScope(jjtn000, true);
17656    jjtc000 = false;
17657  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17658     } catch (Throwable jjte000) {
17659     if (jjtc000) {
17660       jjtree.clearNodeScope(jjtn000);
17661       jjtc000 = false;
17662     } else {
17663       jjtree.popNode();
17664     }
17665     if (jjte000 instanceof RuntimeException) {
17666       {if (true) throw (RuntimeException)jjte000;}
17667     }
17668     if (jjte000 instanceof ParseException) {
17669       {if (true) throw (ParseException)jjte000;}
17670     }
17671     {if (true) throw (Error)jjte000;}
17672     } finally {
17673     if (jjtc000) {
17674       jjtree.closeNodeScope(jjtn000, true);
17675     }
17676     }
17677     throw new Error("Missing return statement in function");
17678   }
17679 
17680   final public ASTEqualityExpression EqualityExpression() throws ParseException {
17681  /*@bgen(jjtree) EqualityExpression */
17682   ASTEqualityExpression jjtn000 = new ASTEqualityExpression(this, JJTEQUALITYEXPRESSION);
17683   boolean jjtc000 = true;
17684   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17685     try {
17686       simpleNode = RelationalExpression();
17687              sb.append(simpleNode.getImage());
17688       label_56:
17689       while (true) {
17690         switch (jj_nt.kind) {
17691         case 10:
17692         case 13:
17693         case IS:
17694           ;
17695           break;
17696         default:
17697           jj_la1[225] = jj_gen;
17698           break label_56;
17699         }
17700         switch (jj_nt.kind) {
17701         case 10:
17702           jj_consume_token(10);
17703                      sb.append(" = ");
17704           break;
17705         case 13:
17706           jj_consume_token(13);
17707           jj_consume_token(10);
17708                          sb.append(" != ");
17709           break;
17710         case IS:
17711           jj_consume_token(IS);
17712                      sb.append(" IS ");
17713           break;
17714         default:
17715           jj_la1[226] = jj_gen;
17716           jj_consume_token(-1);
17717           throw new ParseException();
17718         }
17719         simpleNode = RelationalExpression();
17720               sb.append(simpleNode.getImage());
17721       }
17722    jjtree.closeNodeScope(jjtn000, true);
17723    jjtc000 = false;
17724  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17725     } catch (Throwable jjte000) {
17726     if (jjtc000) {
17727       jjtree.clearNodeScope(jjtn000);
17728       jjtc000 = false;
17729     } else {
17730       jjtree.popNode();
17731     }
17732     if (jjte000 instanceof RuntimeException) {
17733       {if (true) throw (RuntimeException)jjte000;}
17734     }
17735     if (jjte000 instanceof ParseException) {
17736       {if (true) throw (ParseException)jjte000;}
17737     }
17738     {if (true) throw (Error)jjte000;}
17739     } finally {
17740     if (jjtc000) {
17741       jjtree.closeNodeScope(jjtn000, true);
17742     }
17743     }
17744     throw new Error("Missing return statement in function");
17745   }
17746 
17747 /**
17748  * 2006-05-23 - Matthias Hendler - added FROM
17749  */
17750   final public ASTRelationalExpression RelationalExpression() throws ParseException {
17751  /*@bgen(jjtree) RelationalExpression */
17752   ASTRelationalExpression jjtn000 = new ASTRelationalExpression(this, JJTRELATIONALEXPRESSION);
17753   boolean jjtc000 = true;
17754   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17755     try {
17756       simpleNode = AdditiveExpression();
17757                                          sb.append(simpleNode.getImage());
17758       label_57:
17759       while (true) {
17760         switch (jj_nt.kind) {
17761         case 14:
17762         case 15:
17763         case BETWEEN:
17764         case FROM:
17765         case IN:
17766         case LIKE:
17767         case MEMBER:
17768         case NOT:
17769         case MULTISET:
17770         case SUBMULTISET:
17771           ;
17772           break;
17773         default:
17774           jj_la1[227] = jj_gen;
17775           break label_57;
17776         }
17777         switch (jj_nt.kind) {
17778         case 14:
17779         case 15:
17780           switch (jj_nt.kind) {
17781           case 14:
17782             jj_consume_token(14);
17783                       sb.append("<");
17784             switch (jj_nt.kind) {
17785             case 15:
17786               jj_consume_token(15);
17787                      sb.append(">");
17788               break;
17789             default:
17790               jj_la1[228] = jj_gen;
17791               ;
17792             }
17793             break;
17794           case 15:
17795             jj_consume_token(15);
17796                      sb.append(">");
17797             break;
17798           default:
17799             jj_la1[229] = jj_gen;
17800             jj_consume_token(-1);
17801             throw new ParseException();
17802           }
17803           switch (jj_nt.kind) {
17804           case 10:
17805             jj_consume_token(10);
17806                    sb.append("=");
17807             break;
17808           default:
17809             jj_la1[230] = jj_gen;
17810             ;
17811           }
17812         sb.append(" ");
17813           break;
17814         case BETWEEN:
17815         case FROM:
17816         case IN:
17817         case LIKE:
17818         case MEMBER:
17819         case NOT:
17820         case SUBMULTISET:
17821           switch (jj_nt.kind) {
17822           case NOT:
17823             jj_consume_token(NOT);
17824                 sb.append(" NOT ");
17825             break;
17826           default:
17827             jj_la1[231] = jj_gen;
17828             ;
17829           }
17830           switch (jj_nt.kind) {
17831           case IN:
17832             jj_consume_token(IN);
17833                sb.append(" IN ");
17834             break;
17835           case BETWEEN:
17836             jj_consume_token(BETWEEN);
17837                       sb.append(" BETWEEN ");
17838             break;
17839           case LIKE:
17840             jj_consume_token(LIKE);
17841                    sb.append(" LIKE ");
17842             break;
17843           case FROM:
17844             jj_consume_token(FROM);
17845                   sb.append(" FROM ");
17846             break;
17847           case MEMBER:
17848           case SUBMULTISET:
17849             switch (jj_nt.kind) {
17850             case MEMBER:
17851               jj_consume_token(MEMBER);
17852                         sb.append(" MEMBER ");
17853               break;
17854             case SUBMULTISET:
17855               jj_consume_token(SUBMULTISET);
17856                              sb.append(" SUBMULTISET ");
17857               break;
17858             default:
17859               jj_la1[232] = jj_gen;
17860               jj_consume_token(-1);
17861               throw new ParseException();
17862             }
17863             switch (jj_nt.kind) {
17864             case OF:
17865               jj_consume_token(OF);
17866                   sb.append(" OF ");
17867               break;
17868             default:
17869               jj_la1[233] = jj_gen;
17870               ;
17871             }
17872             break;
17873           default:
17874             jj_la1[234] = jj_gen;
17875             jj_consume_token(-1);
17876             throw new ParseException();
17877           }
17878           break;
17879         case MULTISET:
17880           jj_consume_token(MULTISET);
17881                     sb.append (" MULTISET " );
17882           switch (jj_nt.kind) {
17883           case EXCEPT:
17884             jj_consume_token(EXCEPT);
17885                        sb.append (" EXCEPT " );
17886             break;
17887           case INTERSECT:
17888             jj_consume_token(INTERSECT);
17889                           sb.append (" INTERSECT " );
17890             break;
17891           case UNION:
17892             jj_consume_token(UNION);
17893                       sb.append (" UNION " );
17894             break;
17895           default:
17896             jj_la1[235] = jj_gen;
17897             jj_consume_token(-1);
17898             throw new ParseException();
17899           }
17900           switch (jj_nt.kind) {
17901           case ALL:
17902           case DISTINCT:
17903             switch (jj_nt.kind) {
17904             case DISTINCT:
17905               jj_consume_token(DISTINCT);
17906                          sb.append (" DISTINCT " );
17907               break;
17908             case ALL:
17909               jj_consume_token(ALL);
17910                     sb.append (" ALL " );
17911               break;
17912             default:
17913               jj_la1[236] = jj_gen;
17914               jj_consume_token(-1);
17915               throw new ParseException();
17916             }
17917             break;
17918           default:
17919             jj_la1[237] = jj_gen;
17920             ;
17921           }
17922           break;
17923         default:
17924           jj_la1[238] = jj_gen;
17925           jj_consume_token(-1);
17926           throw new ParseException();
17927         }
17928         AdditiveExpression();
17929                              sb.append(simpleNode.getImage());
17930         switch (jj_nt.kind) {
17931         case ESCAPE:
17932           jj_consume_token(ESCAPE);
17933                    sb.append(" ESCAPE ");
17934           switch (jj_nt.kind) {
17935           case CHARACTER_LITERAL:
17936             jj_consume_token(CHARACTER_LITERAL);
17937                                 sb.append(" "); sb.append(token.toString());
17938             break;
17939           case STRING_LITERAL:
17940             simpleNode = StringLiteral();
17941                                            sb.append(" "); sb.append(simpleNode.getImage());
17942             break;
17943           default:
17944             jj_la1[239] = jj_gen;
17945             jj_consume_token(-1);
17946             throw new ParseException();
17947           }
17948           break;
17949         default:
17950           jj_la1[240] = jj_gen;
17951           ;
17952         }
17953       }
17954    jjtree.closeNodeScope(jjtn000, true);
17955    jjtc000 = false;
17956  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17957     } catch (Throwable jjte000) {
17958    if (jjtc000) {
17959      jjtree.clearNodeScope(jjtn000);
17960      jjtc000 = false;
17961    } else {
17962      jjtree.popNode();
17963    }
17964    if (jjte000 instanceof RuntimeException) {
17965      {if (true) throw (RuntimeException)jjte000;}
17966    }
17967    if (jjte000 instanceof ParseException) {
17968      {if (true) throw (ParseException)jjte000;}
17969    }
17970    {if (true) throw (Error)jjte000;}
17971     } finally {
17972    if (jjtc000) {
17973      jjtree.closeNodeScope(jjtn000, true);
17974    }
17975     }
17976     throw new Error("Missing return statement in function");
17977   }
17978 
17979   final public ASTAdditiveExpression AdditiveExpression() throws ParseException {
17980  /*@bgen(jjtree) AdditiveExpression */
17981   ASTAdditiveExpression jjtn000 = new ASTAdditiveExpression(this, JJTADDITIVEEXPRESSION);
17982   boolean jjtc000 = true;
17983   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17984     try {
17985       simpleNode = MultiplicativeExpression();
17986                                                sb.append(simpleNode.getImage());
17987       label_58:
17988       while (true) {
17989         switch (jj_nt.kind) {
17990         case 16:
17991         case 17:
17992         case 18:
17993           ;
17994           break;
17995         default:
17996           jj_la1[241] = jj_gen;
17997           break label_58;
17998         }
17999         switch (jj_nt.kind) {
18000         case 16:
18001           jj_consume_token(16);
18002                sb.append(" + ");
18003           break;
18004         case 17:
18005           jj_consume_token(17);
18006                sb.append(" - ");
18007           break;
18008         case 18:
18009           jj_consume_token(18);
18010                 sb.append(" || ");
18011           break;
18012         default:
18013           jj_la1[242] = jj_gen;
18014           jj_consume_token(-1);
18015           throw new ParseException();
18016         }
18017         simpleNode = MultiplicativeExpression();
18018                                                  sb.append(simpleNode.getImage());
18019       }
18020    jjtree.closeNodeScope(jjtn000, true);
18021    jjtc000 = false;
18022  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18023     } catch (Throwable jjte000) {
18024    if (jjtc000) {
18025      jjtree.clearNodeScope(jjtn000);
18026      jjtc000 = false;
18027    } else {
18028      jjtree.popNode();
18029    }
18030    if (jjte000 instanceof RuntimeException) {
18031      {if (true) throw (RuntimeException)jjte000;}
18032    }
18033    if (jjte000 instanceof ParseException) {
18034      {if (true) throw (ParseException)jjte000;}
18035    }
18036    {if (true) throw (Error)jjte000;}
18037     } finally {
18038    if (jjtc000) {
18039      jjtree.closeNodeScope(jjtn000, true);
18040    }
18041     }
18042     throw new Error("Missing return statement in function");
18043   }
18044 
18045   final public ASTStringExpression StringExpression() throws ParseException {
18046  /*@bgen(jjtree) StringExpression */
18047   ASTStringExpression jjtn000 = new ASTStringExpression(this, JJTSTRINGEXPRESSION);
18048   boolean jjtc000 = true;
18049   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18050     try {
18051       simpleNode = PrimaryExpression();
18052                                         sb.append(simpleNode.getImage());
18053       label_59:
18054       while (true) {
18055         switch (jj_nt.kind) {
18056         case 18:
18057           ;
18058           break;
18059         default:
18060           jj_la1[243] = jj_gen;
18061           break label_59;
18062         }
18063         jj_consume_token(18);
18064                sb.append(" || ");
18065         simpleNode = PrimaryExpression();
18066                                           sb.append(simpleNode.getImage());
18067       }
18068    jjtree.closeNodeScope(jjtn000, true);
18069    jjtc000 = false;
18070  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18071     } catch (Throwable jjte000) {
18072    if (jjtc000) {
18073      jjtree.clearNodeScope(jjtn000);
18074      jjtc000 = false;
18075    } else {
18076      jjtree.popNode();
18077    }
18078    if (jjte000 instanceof RuntimeException) {
18079      {if (true) throw (RuntimeException)jjte000;}
18080    }
18081    if (jjte000 instanceof ParseException) {
18082      {if (true) throw (ParseException)jjte000;}
18083    }
18084    {if (true) throw (Error)jjte000;}
18085     } finally {
18086    if (jjtc000) {
18087      jjtree.closeNodeScope(jjtn000, true);
18088    }
18089     }
18090     throw new Error("Missing return statement in function");
18091   }
18092 
18093   final public ASTMultiplicativeExpression MultiplicativeExpression() throws ParseException {
18094  /*@bgen(jjtree) MultiplicativeExpression */
18095   ASTMultiplicativeExpression jjtn000 = new ASTMultiplicativeExpression(this, JJTMULTIPLICATIVEEXPRESSION);
18096   boolean jjtc000 = true;
18097   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18098     try {
18099       simpleNode = UnaryExpression(true);
18100                                           sb.append(simpleNode.getImage());
18101       label_60:
18102       while (true) {
18103         switch (jj_nt.kind) {
18104         case 1:
18105         case 19:
18106         case 20:
18107         case MOD:
18108           ;
18109           break;
18110         default:
18111           jj_la1[244] = jj_gen;
18112           break label_60;
18113         }
18114         switch (jj_nt.kind) {
18115         case 19:
18116           jj_consume_token(19);
18117                  sb.append(" ** ");
18118           break;
18119         case 20:
18120           jj_consume_token(20);
18121                 sb.append(" * ");
18122           break;
18123         case 1:
18124           jj_consume_token(1);
18125                 sb.append(" / ");
18126           break;
18127         case MOD:
18128           jj_consume_token(MOD);
18129                   sb.append(" MOD ");
18130           break;
18131         default:
18132           jj_la1[245] = jj_gen;
18133           jj_consume_token(-1);
18134           throw new ParseException();
18135         }
18136         simpleNode = UnaryExpression(true);
18137                                             sb.append(simpleNode.getImage());
18138       }
18139    jjtree.closeNodeScope(jjtn000, true);
18140    jjtc000 = false;
18141  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18142     } catch (Throwable jjte000) {
18143    if (jjtc000) {
18144      jjtree.clearNodeScope(jjtn000);
18145      jjtc000 = false;
18146    } else {
18147      jjtree.popNode();
18148    }
18149    if (jjte000 instanceof RuntimeException) {
18150      {if (true) throw (RuntimeException)jjte000;}
18151    }
18152    if (jjte000 instanceof ParseException) {
18153      {if (true) throw (ParseException)jjte000;}
18154    }
18155    {if (true) throw (Error)jjte000;}
18156     } finally {
18157    if (jjtc000) {
18158      jjtree.closeNodeScope(jjtn000, true);
18159    }
18160     }
18161     throw new Error("Missing return statement in function");
18162   }
18163 
18164   final public ASTUnaryExpression UnaryExpression(boolean isUnarySign) throws ParseException {
18165  /*@bgen(jjtree) UnaryExpression */
18166   ASTUnaryExpression jjtn000 = new ASTUnaryExpression(this, JJTUNARYEXPRESSION);
18167   boolean jjtc000 = true;
18168   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18169     try {
18170       switch (jj_nt.kind) {
18171       case 16:
18172       case 17:
18173         switch (jj_nt.kind) {
18174         case 16:
18175           jj_consume_token(16);
18176               sb.append(isUnarySign ? " +" : " + ");
18177           break;
18178         case 17:
18179           jj_consume_token(17);
18180               sb.append(isUnarySign ? " -" : " - ");
18181           break;
18182         default:
18183           jj_la1[246] = jj_gen;
18184           jj_consume_token(-1);
18185           throw new ParseException();
18186         }
18187         simpleNode = UnaryExpression(false);
18188                                             sb.append(simpleNode.getImage());
18189         break;
18190       case 5:
18191       case REPLACE:
18192       case DEFINER:
18193       case CURRENT_USER:
18194       case LANGUAGE:
18195       case ADD:
18196       case AGGREGATE:
18197       case ARRAY:
18198       case AT:
18199       case ATTRIBUTE:
18200       case AUTHID:
18201       case BODY:
18202       case BULK:
18203       case BYTE:
18204       case CASCADE:
18205       case CASE:
18206       case CLOSE:
18207       case COALESCE:
18208       case COLLECT:
18209       case COLUMN:
18210       case COMMENT:
18211       case COMMIT:
18212       case CONSTRUCTOR:
18213       case CONTINUE:
18214       case CONVERT:
18215       case CURRENT:
18216       case CURSOR:
18217       case DATA:
18218       case DATE:
18219       case DAY:
18220       case DISABLE:
18221       case EDITIONABLE:
18222       case ELEMENT:
18223       case ENABLE:
18224       case ESCAPE:
18225       case EXCEPT:
18226       case EXCEPTIONS:
18227       case EXIT:
18228       case EXTERNAL:
18229       case EXTENDS:
18230       case EXTRACT:
18231       case FALSE:
18232       case FINAL:
18233       case FORCE:
18234       case FUNCTION:
18235       case GLOBAL:
18236       case HASH:
18237       case HEAP:
18238       case HOUR:
18239       case IMMEDIATE:
18240       case INDICES:
18241       case INDEXTYPE:
18242       case INDICATOR:
18243       case INSTANTIABLE:
18244       case INTERVAL:
18245       case INVALIDATE:
18246       case ISOLATION:
18247       case JAVA:
18248       case LEVEL:
18249       case LIMIT:
18250       case LOOP:
18251       case MAP:
18252       case MAX:
18253       case MEMBER:
18254       case MERGE:
18255       case MIN:
18256       case MINUTE:
18257       case MLSLABEL:
18258       case MODIFY:
18259       case MOD:
18260       case MONTH:
18261       case NATURAL:
18262       case NEW:
18263       case NEW_DOT:
18264       case NO:
18265       case NONEDITIONABLE:
18266       case NOT:
18267       case NULL:
18268       case NULLIF:
18269       case OBJECT:
18270       case OID:
18271       case OPAQUE:
18272       case OPEN:
18273       case OPERATOR:
18274       case ORGANIZATION:
18275       case OTHERS:
18276       case OVERRIDING:
18277       case PACKAGE:
18278       case PARTITION:
18279       case PRESERVE:
18280       case PRIVATE:
18281       case PROCEDURE:
18282       case RANGE:
18283       case RAW:
18284       case REAL:
18285       case RECORD:
18286       case REF:
18287       case RELEASE:
18288       case RELIES_ON:
18289       case RENAME:
18290       case RESULT:
18291       case RETURN:
18292       case RETURNING:
18293       case REVERSE:
18294       case ROLLBACK:
18295       case ROW:
18296       case ROWS:
18297       case ROWID:
18298       case ROWNUM:
18299       case SAVE:
18300       case SAVEPOINT:
18301       case SECOND:
18302       case SELECT:
18303       case SELF:
18304       case SET:
18305       case SPACE:
18306       case SQL:
18307       case SQLCODE:
18308       case SQLERRM:
18309       case STATIC:
18310       case SUBTYPE:
18311       case SUBSTITUTABLE:
18312       case SUCCESSFUL:
18313       case SYSDATE:
18314       case SYS_REFCURSOR:
18315       case TEMPORARY:
18316       case TIME:
18317       case TIMESTAMP:
18318       case TIMEZONE_REGION:
18319       case TIMEZONE_ABBR:
18320       case TIMEZONE_MINUTE:
18321       case TIMEZONE_HOUR:
18322       case TRANSACTION:
18323       case TRUE:
18324       case TYPE:
18325       case UNDER:
18326       case USING:
18327       case YES:
18328       case SHOW:
18329       case A:
18330       case DOUBLE:
18331       case DEC:
18332       case PRECISION:
18333       case INT:
18334       case NUMERIC:
18335       case NCHAR:
18336       case NVARCHAR2:
18337       case STRING:
18338       case UROWID:
18339       case VARRAY:
18340       case VARYING:
18341       case BFILE:
18342       case BLOB:
18343       case CLOB:
18344       case NCLOB:
18345       case YEAR:
18346       case LOCAL:
18347       case WITH:
18348       case ZONE:
18349       case CHARACTER:
18350       case AFTER:
18351       case BEFORE:
18352       case OLD:
18353       case PARENT:
18354       case ANALYZE:
18355       case ASSOCIATE:
18356       case AUDIT:
18357       case COMPOUND:
18358       case DATABASE:
18359       case CALL:
18360       case DDL:
18361       case DISASSOCIATE:
18362       case EACH:
18363       case FOLLOWS:
18364       case LOGOFF:
18365       case LOGON:
18366       case NESTED:
18367       case NOAUDIT:
18368       case SCHEMA:
18369       case SERVERERROR:
18370       case SHUTDOWN:
18371       case STARTUP:
18372       case STATEMENT:
18373       case STATISTICS:
18374       case SUSPEND:
18375       case TRUNCATE:
18376       case WRAPPED:
18377       case LIBRARY:
18378       case NAME:
18379       case STRUCT:
18380       case CONTEXT:
18381       case PARAMETERS:
18382       case LENGTH:
18383       case TDO:
18384       case MAXLEN:
18385       case CHARSETID:
18386       case CHARSETFORM:
18387       case ACCEPT:
18388       case ACCESSIBLE:
18389       case COPY:
18390       case DEFINE:
18391       case DISCONNECT:
18392       case HOST:
18393       case PRINT:
18394       case QUIT:
18395       case REMARK:
18396       case UNDEFINE:
18397       case VARIABLE:
18398       case WHENEVER:
18399       case ATTACH:
18400       case CAST:
18401       case TREAT:
18402       case TRIM:
18403       case LEFT:
18404       case RIGHT:
18405       case BOTH:
18406       case EMPTY:
18407       case MULTISET:
18408       case SUBMULTISET:
18409       case LEADING:
18410       case TRAILING:
18411       case CHAR_CS:
18412       case NCHAR_CS:
18413       case DBTIMEZONE:
18414       case SESSIONTIMEZONE:
18415       case AUTHENTICATED:
18416       case LINK:
18417       case SHARED:
18418       case DIRECTORY:
18419       case USER:
18420       case IDENTIFIER:
18421       case UNSIGNED_NUMERIC_LITERAL:
18422       case CHARACTER_LITERAL:
18423       case STRING_LITERAL:
18424       case QUOTED_LITERAL:
18425         simpleNode = UnaryExpressionNotPlusMinus();
18426                                                    sb.append(simpleNode.getImage());
18427         break;
18428       default:
18429         jj_la1[247] = jj_gen;
18430         jj_consume_token(-1);
18431         throw new ParseException();
18432       }
18433    jjtree.closeNodeScope(jjtn000, true);
18434    jjtc000 = false;
18435  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18436     } catch (Throwable jjte000) {
18437    if (jjtc000) {
18438      jjtree.clearNodeScope(jjtn000);
18439      jjtc000 = false;
18440    } else {
18441      jjtree.popNode();
18442    }
18443    if (jjte000 instanceof RuntimeException) {
18444      {if (true) throw (RuntimeException)jjte000;}
18445    }
18446    if (jjte000 instanceof ParseException) {
18447      {if (true) throw (ParseException)jjte000;}
18448    }
18449    {if (true) throw (Error)jjte000;}
18450     } finally {
18451    if (jjtc000) {
18452      jjtree.closeNodeScope(jjtn000, true);
18453    }
18454     }
18455     throw new Error("Missing return statement in function");
18456   }
18457 
18458   final public ASTUnaryExpressionNotPlusMinus UnaryExpressionNotPlusMinus() throws ParseException {
18459  /*@bgen(jjtree) UnaryExpressionNotPlusMinus */
18460   ASTUnaryExpressionNotPlusMinus jjtn000 = new ASTUnaryExpressionNotPlusMinus(this, JJTUNARYEXPRESSIONNOTPLUSMINUS);
18461   boolean jjtc000 = true;
18462   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18463     try {
18464       switch (jj_nt.kind) {
18465       case NOT:
18466         jj_consume_token(NOT);
18467            sb.append(" NOT ");
18468         simpleNode = UnaryExpression(false);
18469                                            sb.append(simpleNode.getImage());
18470         break;
18471       case 5:
18472       case REPLACE:
18473       case DEFINER:
18474       case CURRENT_USER:
18475       case LANGUAGE:
18476       case ADD:
18477       case AGGREGATE:
18478       case ARRAY:
18479       case AT:
18480       case ATTRIBUTE:
18481       case AUTHID:
18482       case BODY:
18483       case BULK:
18484       case BYTE:
18485       case CASCADE:
18486       case CASE:
18487       case CLOSE:
18488       case COALESCE:
18489       case COLLECT:
18490       case COLUMN:
18491       case COMMENT:
18492       case COMMIT:
18493       case CONSTRUCTOR:
18494       case CONTINUE:
18495       case CONVERT:
18496       case CURRENT:
18497       case CURSOR:
18498       case DATA:
18499       case DATE:
18500       case DAY:
18501       case DISABLE:
18502       case EDITIONABLE:
18503       case ELEMENT:
18504       case ENABLE:
18505       case ESCAPE:
18506       case EXCEPT:
18507       case EXCEPTIONS:
18508       case EXIT:
18509       case EXTERNAL:
18510       case EXTENDS:
18511       case EXTRACT:
18512       case FALSE:
18513       case FINAL:
18514       case FORCE:
18515       case FUNCTION:
18516       case GLOBAL:
18517       case HASH:
18518       case HEAP:
18519       case HOUR:
18520       case IMMEDIATE:
18521       case INDICES:
18522       case INDEXTYPE:
18523       case INDICATOR:
18524       case INSTANTIABLE:
18525       case INTERVAL:
18526       case INVALIDATE:
18527       case ISOLATION:
18528       case JAVA:
18529       case LEVEL:
18530       case LIMIT:
18531       case LOOP:
18532       case MAP:
18533       case MAX:
18534       case MEMBER:
18535       case MERGE:
18536       case MIN:
18537       case MINUTE:
18538       case MLSLABEL:
18539       case MODIFY:
18540       case MOD:
18541       case MONTH:
18542       case NATURAL:
18543       case NEW:
18544       case NEW_DOT:
18545       case NO:
18546       case NONEDITIONABLE:
18547       case NULL:
18548       case NULLIF:
18549       case OBJECT:
18550       case OID:
18551       case OPAQUE:
18552       case OPEN:
18553       case OPERATOR:
18554       case ORGANIZATION:
18555       case OTHERS:
18556       case OVERRIDING:
18557       case PACKAGE:
18558       case PARTITION:
18559       case PRESERVE:
18560       case PRIVATE:
18561       case PROCEDURE:
18562       case RANGE:
18563       case RAW:
18564       case REAL:
18565       case RECORD:
18566       case REF:
18567       case RELEASE:
18568       case RELIES_ON:
18569       case RENAME:
18570       case RESULT:
18571       case RETURN:
18572       case RETURNING:
18573       case REVERSE:
18574       case ROLLBACK:
18575       case ROW:
18576       case ROWS:
18577       case ROWID:
18578       case ROWNUM:
18579       case SAVE:
18580       case SAVEPOINT:
18581       case SECOND:
18582       case SELECT:
18583       case SELF:
18584       case SET:
18585       case SPACE:
18586       case SQL:
18587       case SQLCODE:
18588       case SQLERRM:
18589       case STATIC:
18590       case SUBTYPE:
18591       case SUBSTITUTABLE:
18592       case SUCCESSFUL:
18593       case SYSDATE:
18594       case SYS_REFCURSOR:
18595       case TEMPORARY:
18596       case TIME:
18597       case TIMESTAMP:
18598       case TIMEZONE_REGION:
18599       case TIMEZONE_ABBR:
18600       case TIMEZONE_MINUTE:
18601       case TIMEZONE_HOUR:
18602       case TRANSACTION:
18603       case TRUE:
18604       case TYPE:
18605       case UNDER:
18606       case USING:
18607       case YES:
18608       case SHOW:
18609       case A:
18610       case DOUBLE:
18611       case DEC:
18612       case PRECISION:
18613       case INT:
18614       case NUMERIC:
18615       case NCHAR:
18616       case NVARCHAR2:
18617       case STRING:
18618       case UROWID:
18619       case VARRAY:
18620       case VARYING:
18621       case BFILE:
18622       case BLOB:
18623       case CLOB:
18624       case NCLOB:
18625       case YEAR:
18626       case LOCAL:
18627       case WITH:
18628       case ZONE:
18629       case CHARACTER:
18630       case AFTER:
18631       case BEFORE:
18632       case OLD:
18633       case PARENT:
18634       case ANALYZE:
18635       case ASSOCIATE:
18636       case AUDIT:
18637       case COMPOUND:
18638       case DATABASE:
18639       case CALL:
18640       case DDL:
18641       case DISASSOCIATE:
18642       case EACH:
18643       case FOLLOWS:
18644       case LOGOFF:
18645       case LOGON:
18646       case NESTED:
18647       case NOAUDIT:
18648       case SCHEMA:
18649       case SERVERERROR:
18650       case SHUTDOWN:
18651       case STARTUP:
18652       case STATEMENT:
18653       case STATISTICS:
18654       case SUSPEND:
18655       case TRUNCATE:
18656       case WRAPPED:
18657       case LIBRARY:
18658       case NAME:
18659       case STRUCT:
18660       case CONTEXT:
18661       case PARAMETERS:
18662       case LENGTH:
18663       case TDO:
18664       case MAXLEN:
18665       case CHARSETID:
18666       case CHARSETFORM:
18667       case ACCEPT:
18668       case ACCESSIBLE:
18669       case COPY:
18670       case DEFINE:
18671       case DISCONNECT:
18672       case HOST:
18673       case PRINT:
18674       case QUIT:
18675       case REMARK:
18676       case UNDEFINE:
18677       case VARIABLE:
18678       case WHENEVER:
18679       case ATTACH:
18680       case CAST:
18681       case TREAT:
18682       case TRIM:
18683       case LEFT:
18684       case RIGHT:
18685       case BOTH:
18686       case EMPTY:
18687       case MULTISET:
18688       case SUBMULTISET:
18689       case LEADING:
18690       case TRAILING:
18691       case CHAR_CS:
18692       case NCHAR_CS:
18693       case DBTIMEZONE:
18694       case SESSIONTIMEZONE:
18695       case AUTHENTICATED:
18696       case LINK:
18697       case SHARED:
18698       case DIRECTORY:
18699       case USER:
18700       case IDENTIFIER:
18701       case UNSIGNED_NUMERIC_LITERAL:
18702       case CHARACTER_LITERAL:
18703       case STRING_LITERAL:
18704       case QUOTED_LITERAL:
18705         simpleNode = PrimaryExpression();
18706                                          sb.append(simpleNode.getImage());
18707         break;
18708       default:
18709         jj_la1[248] = jj_gen;
18710         jj_consume_token(-1);
18711         throw new ParseException();
18712       }
18713    jjtree.closeNodeScope(jjtn000, true);
18714    jjtc000 = false;
18715  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18716     } catch (Throwable jjte000) {
18717     if (jjtc000) {
18718       jjtree.clearNodeScope(jjtn000);
18719       jjtc000 = false;
18720     } else {
18721       jjtree.popNode();
18722     }
18723     if (jjte000 instanceof RuntimeException) {
18724       {if (true) throw (RuntimeException)jjte000;}
18725     }
18726     if (jjte000 instanceof ParseException) {
18727       {if (true) throw (ParseException)jjte000;}
18728     }
18729     {if (true) throw (Error)jjte000;}
18730     } finally {
18731     if (jjtc000) {
18732       jjtree.closeNodeScope(jjtn000, true);
18733     }
18734     }
18735     throw new Error("Missing return statement in function");
18736   }
18737 
18738 /**
18739  * 2006-05-23 - Matthias Hendler - Added lookahead otherwise warning encountered.
18740  *                                 Warning arised while adding methode triggerUnit(). 
18741  * 2011-04-27 - SRT - Add optional NEW Keyword to cope with Object Type constructors
18742  */
18743   final public ASTPrimaryExpression PrimaryExpression() throws ParseException {
18744  /*@bgen(jjtree) PrimaryExpression */
18745   ASTPrimaryExpression jjtn000 = new ASTPrimaryExpression(this, JJTPRIMARYEXPRESSION);
18746   boolean jjtc000 = true;
18747   jjtree.openNodeScope(jjtn000);Token thisToken ; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18748     try {
18749       switch (jj_nt.kind) {
18750       case NEW_DOT:
18751         jj_consume_token(NEW_DOT);
18752         simpleNode = QualifiedID();
18753                                                        sb.append(" NEW."); sb.append(simpleNode.getImage());
18754         break;
18755       case 5:
18756       case REPLACE:
18757       case DEFINER:
18758       case CURRENT_USER:
18759       case LANGUAGE:
18760       case ADD:
18761       case AGGREGATE:
18762       case ARRAY:
18763       case AT:
18764       case ATTRIBUTE:
18765       case AUTHID:
18766       case BODY:
18767       case BULK:
18768       case BYTE:
18769       case CASCADE:
18770       case CASE:
18771       case CLOSE:
18772       case COALESCE:
18773       case COLLECT:
18774       case COLUMN:
18775       case COMMENT:
18776       case COMMIT:
18777       case CONSTRUCTOR:
18778       case CONTINUE:
18779       case CONVERT:
18780       case CURRENT:
18781       case CURSOR:
18782       case DATA:
18783       case DATE:
18784       case DAY:
18785       case DISABLE:
18786       case EDITIONABLE:
18787       case ELEMENT:
18788       case ENABLE:
18789       case ESCAPE:
18790       case EXCEPT:
18791       case EXCEPTIONS:
18792       case EXIT:
18793       case EXTERNAL:
18794       case EXTENDS:
18795       case EXTRACT:
18796       case FALSE:
18797       case FINAL:
18798       case FORCE:
18799       case FUNCTION:
18800       case GLOBAL:
18801       case HASH:
18802       case HEAP:
18803       case HOUR:
18804       case IMMEDIATE:
18805       case INDICES:
18806       case INDEXTYPE:
18807       case INDICATOR:
18808       case INSTANTIABLE:
18809       case INTERVAL:
18810       case INVALIDATE:
18811       case ISOLATION:
18812       case JAVA:
18813       case LEVEL:
18814       case LIMIT:
18815       case LOOP:
18816       case MAP:
18817       case MAX:
18818       case MEMBER:
18819       case MERGE:
18820       case MIN:
18821       case MINUTE:
18822       case MLSLABEL:
18823       case MODIFY:
18824       case MOD:
18825       case MONTH:
18826       case NATURAL:
18827       case NEW:
18828       case NO:
18829       case NONEDITIONABLE:
18830       case NULL:
18831       case NULLIF:
18832       case OBJECT:
18833       case OID:
18834       case OPAQUE:
18835       case OPEN:
18836       case OPERATOR:
18837       case ORGANIZATION:
18838       case OTHERS:
18839       case OVERRIDING:
18840       case PACKAGE:
18841       case PARTITION:
18842       case PRESERVE:
18843       case PRIVATE:
18844       case PROCEDURE:
18845       case RANGE:
18846       case RAW:
18847       case REAL:
18848       case RECORD:
18849       case REF:
18850       case RELEASE:
18851       case RELIES_ON:
18852       case RENAME:
18853       case RESULT:
18854       case RETURN:
18855       case RETURNING:
18856       case REVERSE:
18857       case ROLLBACK:
18858       case ROW:
18859       case ROWS:
18860       case ROWID:
18861       case ROWNUM:
18862       case SAVE:
18863       case SAVEPOINT:
18864       case SECOND:
18865       case SELECT:
18866       case SELF:
18867       case SET:
18868       case SPACE:
18869       case SQL:
18870       case SQLCODE:
18871       case SQLERRM:
18872       case STATIC:
18873       case SUBTYPE:
18874       case SUBSTITUTABLE:
18875       case SUCCESSFUL:
18876       case SYSDATE:
18877       case SYS_REFCURSOR:
18878       case TEMPORARY:
18879       case TIME:
18880       case TIMESTAMP:
18881       case TIMEZONE_REGION:
18882       case TIMEZONE_ABBR:
18883       case TIMEZONE_MINUTE:
18884       case TIMEZONE_HOUR:
18885       case TRANSACTION:
18886       case TRUE:
18887       case TYPE:
18888       case UNDER:
18889       case USING:
18890       case YES:
18891       case SHOW:
18892       case A:
18893       case DOUBLE:
18894       case DEC:
18895       case PRECISION:
18896       case INT:
18897       case NUMERIC:
18898       case NCHAR:
18899       case NVARCHAR2:
18900       case STRING:
18901       case UROWID:
18902       case VARRAY:
18903       case VARYING:
18904       case BFILE:
18905       case BLOB:
18906       case CLOB:
18907       case NCLOB:
18908       case YEAR:
18909       case LOCAL:
18910       case WITH:
18911       case ZONE:
18912       case CHARACTER:
18913       case AFTER:
18914       case BEFORE:
18915       case OLD:
18916       case PARENT:
18917       case ANALYZE:
18918       case ASSOCIATE:
18919       case AUDIT:
18920       case COMPOUND:
18921       case DATABASE:
18922       case CALL:
18923       case DDL:
18924       case DISASSOCIATE:
18925       case EACH:
18926       case FOLLOWS:
18927       case LOGOFF:
18928       case LOGON:
18929       case NESTED:
18930       case NOAUDIT:
18931       case SCHEMA:
18932       case SERVERERROR:
18933       case SHUTDOWN:
18934       case STARTUP:
18935       case STATEMENT:
18936       case STATISTICS:
18937       case SUSPEND:
18938       case TRUNCATE:
18939       case WRAPPED:
18940       case LIBRARY:
18941       case NAME:
18942       case STRUCT:
18943       case CONTEXT:
18944       case PARAMETERS:
18945       case LENGTH:
18946       case TDO:
18947       case MAXLEN:
18948       case CHARSETID:
18949       case CHARSETFORM:
18950       case ACCEPT:
18951       case ACCESSIBLE:
18952       case COPY:
18953       case DEFINE:
18954       case DISCONNECT:
18955       case HOST:
18956       case PRINT:
18957       case QUIT:
18958       case REMARK:
18959       case UNDEFINE:
18960       case VARIABLE:
18961       case WHENEVER:
18962       case ATTACH:
18963       case CAST:
18964       case TREAT:
18965       case TRIM:
18966       case LEFT:
18967       case RIGHT:
18968       case BOTH:
18969       case EMPTY:
18970       case MULTISET:
18971       case SUBMULTISET:
18972       case LEADING:
18973       case TRAILING:
18974       case CHAR_CS:
18975       case NCHAR_CS:
18976       case DBTIMEZONE:
18977       case SESSIONTIMEZONE:
18978       case AUTHENTICATED:
18979       case LINK:
18980       case SHARED:
18981       case DIRECTORY:
18982       case USER:
18983       case IDENTIFIER:
18984       case UNSIGNED_NUMERIC_LITERAL:
18985       case CHARACTER_LITERAL:
18986       case STRING_LITERAL:
18987       case QUOTED_LITERAL:
18988         if (jj_2_46(2147483647)) {
18989           jj_consume_token(NEW);
18990                 sb.append(" NEW ");
18991           simpleNode = PrimaryPrefix();
18992                                                                        sb.append(simpleNode.getImage());
18993         } else {
18994           switch (jj_nt.kind) {
18995           case 5:
18996           case REPLACE:
18997           case DEFINER:
18998           case CURRENT_USER:
18999           case LANGUAGE:
19000           case ADD:
19001           case AGGREGATE:
19002           case ARRAY:
19003           case AT:
19004           case ATTRIBUTE:
19005           case AUTHID:
19006           case BODY:
19007           case BULK:
19008           case BYTE:
19009           case CASCADE:
19010           case CASE:
19011           case CLOSE:
19012           case COALESCE:
19013           case COLLECT:
19014           case COLUMN:
19015           case COMMENT:
19016           case COMMIT:
19017           case CONSTRUCTOR:
19018           case CONTINUE:
19019           case CONVERT:
19020           case CURRENT:
19021           case CURSOR:
19022           case DATA:
19023           case DATE:
19024           case DAY:
19025           case DISABLE:
19026           case EDITIONABLE:
19027           case ELEMENT:
19028           case ENABLE:
19029           case ESCAPE:
19030           case EXCEPT:
19031           case EXCEPTIONS:
19032           case EXIT:
19033           case EXTERNAL:
19034           case EXTENDS:
19035           case EXTRACT:
19036           case FALSE:
19037           case FINAL:
19038           case FORCE:
19039           case FUNCTION:
19040           case GLOBAL:
19041           case HASH:
19042           case HEAP:
19043           case HOUR:
19044           case IMMEDIATE:
19045           case INDICES:
19046           case INDEXTYPE:
19047           case INDICATOR:
19048           case INSTANTIABLE:
19049           case INTERVAL:
19050           case INVALIDATE:
19051           case ISOLATION:
19052           case JAVA:
19053           case LEVEL:
19054           case LIMIT:
19055           case LOOP:
19056           case MAP:
19057           case MAX:
19058           case MEMBER:
19059           case MERGE:
19060           case MIN:
19061           case MINUTE:
19062           case MLSLABEL:
19063           case MODIFY:
19064           case MOD:
19065           case MONTH:
19066           case NATURAL:
19067           case NEW:
19068           case NO:
19069           case NONEDITIONABLE:
19070           case NULL:
19071           case NULLIF:
19072           case OBJECT:
19073           case OID:
19074           case OPAQUE:
19075           case OPEN:
19076           case OPERATOR:
19077           case ORGANIZATION:
19078           case OTHERS:
19079           case OVERRIDING:
19080           case PACKAGE:
19081           case PARTITION:
19082           case PRESERVE:
19083           case PRIVATE:
19084           case PROCEDURE:
19085           case RANGE:
19086           case RAW:
19087           case REAL:
19088           case RECORD:
19089           case REF:
19090           case RELEASE:
19091           case RELIES_ON:
19092           case RENAME:
19093           case RESULT:
19094           case RETURN:
19095           case RETURNING:
19096           case REVERSE:
19097           case ROLLBACK:
19098           case ROW:
19099           case ROWS:
19100           case ROWID:
19101           case ROWNUM:
19102           case SAVE:
19103           case SAVEPOINT:
19104           case SECOND:
19105           case SELECT:
19106           case SELF:
19107           case SET:
19108           case SPACE:
19109           case SQL:
19110           case SQLCODE:
19111           case SQLERRM:
19112           case STATIC:
19113           case SUBTYPE:
19114           case SUBSTITUTABLE:
19115           case SUCCESSFUL:
19116           case SYSDATE:
19117           case SYS_REFCURSOR:
19118           case TEMPORARY:
19119           case TIME:
19120           case TIMESTAMP:
19121           case TIMEZONE_REGION:
19122           case TIMEZONE_ABBR:
19123           case TIMEZONE_MINUTE:
19124           case TIMEZONE_HOUR:
19125           case TRANSACTION:
19126           case TRUE:
19127           case TYPE:
19128           case UNDER:
19129           case USING:
19130           case YES:
19131           case SHOW:
19132           case A:
19133           case DOUBLE:
19134           case DEC:
19135           case PRECISION:
19136           case INT:
19137           case NUMERIC:
19138           case NCHAR:
19139           case NVARCHAR2:
19140           case STRING:
19141           case UROWID:
19142           case VARRAY:
19143           case VARYING:
19144           case BFILE:
19145           case BLOB:
19146           case CLOB:
19147           case NCLOB:
19148           case YEAR:
19149           case LOCAL:
19150           case WITH:
19151           case ZONE:
19152           case CHARACTER:
19153           case AFTER:
19154           case BEFORE:
19155           case OLD:
19156           case PARENT:
19157           case ANALYZE:
19158           case ASSOCIATE:
19159           case AUDIT:
19160           case COMPOUND:
19161           case DATABASE:
19162           case CALL:
19163           case DDL:
19164           case DISASSOCIATE:
19165           case EACH:
19166           case FOLLOWS:
19167           case LOGOFF:
19168           case LOGON:
19169           case NESTED:
19170           case NOAUDIT:
19171           case SCHEMA:
19172           case SERVERERROR:
19173           case SHUTDOWN:
19174           case STARTUP:
19175           case STATEMENT:
19176           case STATISTICS:
19177           case SUSPEND:
19178           case TRUNCATE:
19179           case WRAPPED:
19180           case LIBRARY:
19181           case NAME:
19182           case STRUCT:
19183           case CONTEXT:
19184           case PARAMETERS:
19185           case LENGTH:
19186           case TDO:
19187           case MAXLEN:
19188           case CHARSETID:
19189           case CHARSETFORM:
19190           case ACCEPT:
19191           case ACCESSIBLE:
19192           case COPY:
19193           case DEFINE:
19194           case DISCONNECT:
19195           case HOST:
19196           case PRINT:
19197           case QUIT:
19198           case REMARK:
19199           case UNDEFINE:
19200           case VARIABLE:
19201           case WHENEVER:
19202           case ATTACH:
19203           case CAST:
19204           case TREAT:
19205           case TRIM:
19206           case LEFT:
19207           case RIGHT:
19208           case BOTH:
19209           case EMPTY:
19210           case MULTISET:
19211           case SUBMULTISET:
19212           case LEADING:
19213           case TRAILING:
19214           case CHAR_CS:
19215           case NCHAR_CS:
19216           case DBTIMEZONE:
19217           case SESSIONTIMEZONE:
19218           case AUTHENTICATED:
19219           case LINK:
19220           case SHARED:
19221           case DIRECTORY:
19222           case USER:
19223           case IDENTIFIER:
19224           case UNSIGNED_NUMERIC_LITERAL:
19225           case CHARACTER_LITERAL:
19226           case STRING_LITERAL:
19227           case QUOTED_LITERAL:
19228             simpleNode = PrimaryPrefix();
19229                                                sb.append(simpleNode.getImage());
19230             break;
19231           default:
19232             jj_la1[249] = jj_gen;
19233             jj_consume_token(-1);
19234             throw new ParseException();
19235           }
19236         }
19237         label_61:
19238         while (true) {
19239           if (jj_2_47(2)) {
19240             ;
19241           } else {
19242             break label_61;
19243           }
19244           simpleNode = PrimarySuffix();
19245                                                            sb.append(simpleNode.getImage());
19246         }
19247         break;
19248       default:
19249         jj_la1[250] = jj_gen;
19250         jj_consume_token(-1);
19251         throw new ParseException();
19252       }
19253    jjtree.closeNodeScope(jjtn000, true);
19254    jjtc000 = false;
19255  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
19256     } catch (Throwable jjte000) {
19257     if (jjtc000) {
19258       jjtree.clearNodeScope(jjtn000);
19259       jjtc000 = false;
19260     } else {
19261       jjtree.popNode();
19262     }
19263     if (jjte000 instanceof RuntimeException) {
19264       {if (true) throw (RuntimeException)jjte000;}
19265     }
19266     if (jjte000 instanceof ParseException) {
19267       {if (true) throw (ParseException)jjte000;}
19268     }
19269     {if (true) throw (Error)jjte000;}
19270     } finally {
19271     if (jjtc000) {
19272       jjtree.closeNodeScope(jjtn000, true);
19273     }
19274     }
19275     throw new Error("Missing return statement in function");
19276   }
19277 
19278   final public ASTPrimaryPrefix PrimaryPrefix() throws ParseException {
19279  /*@bgen(jjtree) PrimaryPrefix */
19280   ASTPrimaryPrefix jjtn000 = new ASTPrimaryPrefix(this, JJTPRIMARYPREFIX);
19281   boolean jjtc000 = true;
19282   jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
19283     try {
19284       switch (jj_nt.kind) {
19285       case DATE:
19286       case FALSE:
19287       case INTERVAL:
19288       case NULL:
19289       case TIMESTAMP:
19290       case TRUE:
19291       case UNSIGNED_NUMERIC_LITERAL:
19292       case CHARACTER_LITERAL:
19293       case STRING_LITERAL:
19294         simpleNode = Literal();
19295                                sb.append(simpleNode.getImage()) ;
19296         break;
19297       default:
19298         jj_la1[252] = jj_gen;
19299         if (jj_2_48(2147483647)) {
19300           simpleNode = MultiSetCondition();
19301         } else if (jj_2_49(2147483647)) {
19302           simpleNode = TrimExpression();
19303         } else if (jj_2_50(2147483647)) {
19304           simpleNode = CaseExpression();
19305                                                                  sb.append(simpleNode.getImage()) ;
19306         } else if (jj_2_51(2147483647)) {
19307           simpleNode = ObjectExpression();
19308                                                                        sb.append(simpleNode.getImage()) ;
19309         } else {
19310           switch (jj_nt.kind) {
19311           case REPLACE:
19312           case DEFINER:
19313           case CURRENT_USER:
19314           case LANGUAGE:
19315           case ADD:
19316           case AGGREGATE:
19317           case ARRAY:
19318           case AT:
19319           case ATTRIBUTE:
19320           case AUTHID:
19321           case BODY:
19322           case BULK:
19323           case BYTE:
19324           case CASCADE:
19325           case CLOSE:
19326           case COALESCE:
19327           case COLLECT:
19328           case COLUMN:
19329           case COMMENT:
19330           case COMMIT:
19331           case CONSTRUCTOR:
19332           case CONTINUE:
19333           case CONVERT:
19334           case CURRENT:
19335           case CURSOR:
19336           case DATA:
19337           case DAY:
19338           case DISABLE:
19339           case EDITIONABLE:
19340           case ELEMENT:
19341           case ENABLE:
19342           case ESCAPE:
19343           case EXCEPT:
19344           case EXCEPTIONS:
19345           case EXIT:
19346           case EXTERNAL:
19347           case EXTENDS:
19348           case EXTRACT:
19349           case FALSE:
19350           case FINAL:
19351           case FORCE:
19352           case FUNCTION:
19353           case GLOBAL:
19354           case HASH:
19355           case HEAP:
19356           case HOUR:
19357           case IMMEDIATE:
19358           case INDICES:
19359           case INDEXTYPE:
19360           case INDICATOR:
19361           case INSTANTIABLE:
19362           case INTERVAL:
19363           case INVALIDATE:
19364           case ISOLATION:
19365           case JAVA:
19366           case LEVEL:
19367           case LIMIT:
19368           case LOOP:
19369           case MAP:
19370           case MAX:
19371           case MEMBER:
19372           case MERGE:
19373           case MIN:
19374           case MINUTE:
19375           case MLSLABEL:
19376           case MODIFY:
19377           case MOD:
19378           case MONTH:
19379           case NATURAL:
19380           case NEW:
19381           case NO:
19382           case NONEDITIONABLE:
19383           case NULLIF:
19384           case OBJECT:
19385           case OID:
19386           case OPAQUE:
19387           case OPEN:
19388           case OPERATOR:
19389           case ORGANIZATION:
19390           case OTHERS:
19391           case OVERRIDING:
19392           case PACKAGE:
19393           case PARTITION:
19394           case PRESERVE:
19395           case PRIVATE:
19396           case PROCEDURE:
19397           case RANGE:
19398           case RAW:
19399           case REAL:
19400           case RECORD:
19401           case REF:
19402           case RELEASE:
19403           case RELIES_ON:
19404           case RENAME:
19405           case RESULT:
19406           case RETURN:
19407           case RETURNING:
19408           case REVERSE:
19409           case ROLLBACK:
19410           case ROW:
19411           case ROWS:
19412           case ROWID:
19413           case ROWNUM:
19414           case SAVE:
19415           case SAVEPOINT:
19416           case SECOND:
19417           case SELF:
19418           case SET:
19419           case SPACE:
19420           case SQL:
19421           case SQLCODE:
19422           case SQLERRM:
19423           case STATIC:
19424           case SUBTYPE:
19425           case SUBSTITUTABLE:
19426           case SUCCESSFUL:
19427           case SYSDATE:
19428           case SYS_REFCURSOR:
19429           case TEMPORARY:
19430           case TIME:
19431           case TIMESTAMP:
19432           case TIMEZONE_REGION:
19433           case TIMEZONE_ABBR:
19434           case TIMEZONE_MINUTE:
19435           case TIMEZONE_HOUR:
19436           case TRANSACTION:
19437           case TRUE:
19438           case TYPE:
19439           case UNDER:
19440           case USING:
19441           case YES:
19442           case SHOW:
19443           case A:
19444           case DOUBLE:
19445           case DEC:
19446           case PRECISION:
19447           case INT:
19448           case NUMERIC:
19449           case NCHAR:
19450           case NVARCHAR2:
19451           case STRING:
19452           case UROWID:
19453           case VARRAY:
19454           case VARYING:
19455           case BFILE:
19456           case BLOB:
19457           case CLOB:
19458           case NCLOB:
19459           case YEAR:
19460           case LOCAL:
19461           case ZONE:
19462           case CHARACTER:
19463           case AFTER:
19464           case BEFORE:
19465           case OLD:
19466           case PARENT:
19467           case ANALYZE:
19468           case ASSOCIATE:
19469           case AUDIT:
19470           case COMPOUND:
19471           case DATABASE:
19472           case CALL:
19473           case DDL:
19474           case DISASSOCIATE:
19475           case EACH:
19476           case FOLLOWS:
19477           case LOGOFF:
19478           case LOGON:
19479           case NESTED:
19480           case NOAUDIT:
19481           case SCHEMA:
19482           case SERVERERROR:
19483           case SHUTDOWN:
19484           case STARTUP:
19485           case STATEMENT:
19486           case STATISTICS:
19487           case SUSPEND:
19488           case TRUNCATE:
19489           case WRAPPED:
19490           case LIBRARY:
19491           case NAME:
19492           case STRUCT:
19493           case CONTEXT:
19494           case PARAMETERS:
19495           case LENGTH:
19496           case TDO:
19497           case MAXLEN:
19498           case CHARSETID:
19499           case CHARSETFORM:
19500           case ACCEPT:
19501           case ACCESSIBLE:
19502           case COPY:
19503           case DEFINE:
19504           case DISCONNECT:
19505           case HOST:
19506           case PRINT:
19507           case QUIT:
19508           case REMARK:
19509           case UNDEFINE:
19510           case VARIABLE:
19511           case WHENEVER:
19512           case ATTACH:
19513           case CAST:
19514           case TREAT:
19515           case TRIM:
19516           case LEFT:
19517           case RIGHT:
19518           case BOTH:
19519           case EMPTY:
19520           case MULTISET:
19521           case SUBMULTISET:
19522           case LEADING:
19523           case TRAILING:
19524           case CHAR_CS:
19525           case NCHAR_CS:
19526           case DBTIMEZONE:
19527           case SESSIONTIMEZONE:
19528           case AUTHENTICATED:
19529           case LINK:
19530           case SHARED:
19531           case DIRECTORY:
19532           case USER:
19533           case IDENTIFIER:
19534           case QUOTED_LITERAL:
19535             simpleNode = Name();
19536                            sb.append(simpleNode.getImage()) ;
19537             break;
19538           default:
19539             jj_la1[253] = jj_gen;
19540             if (jj_2_52(2147483647)) {
19541               jj_consume_token(SELECT);
19542                                   sb.append("SELECT ...");
19543               Skip2NextTerminator(null,";");
19544             } else if (jj_2_53(2147483647)) {
19545               jj_consume_token(5);
19546                                     sb.append("(SELECT ...");
19547               Skip2NextTerminator("(",")");
19548               jj_consume_token(7);
19549             } else if (jj_2_54(2147483647)) {
19550               jj_consume_token(WITH);
19551                               sb.append("WITH ...");
19552               Skip2NextTerminator(null,";");
19553             } else if (jj_2_55(2147483647)) {
19554               jj_consume_token(5);
19555                                   sb.append("(WITH ...");
19556               Skip2NextTerminator("(",")");
19557               jj_consume_token(7);
19558             } else {
19559               switch (jj_nt.kind) {
19560               case 5:
19561                 jj_consume_token(5);
19562           sb.append("(");
19563                 simpleNode = Expression();
19564                                 sb.append(simpleNode.getImage());
19565                 label_62:
19566                 while (true) {
19567                   switch (jj_nt.kind) {
19568                   case 6:
19569                     ;
19570                     break;
19571                   default:
19572                     jj_la1[251] = jj_gen;
19573                     break label_62;
19574                   }
19575                   jj_consume_token(6);
19576            sb.append(", ");
19577                   simpleNode = Expression();
19578                                   sb.append(simpleNode.getImage());
19579                 }
19580                 jj_consume_token(7);
19581          sb.append(")");
19582                 break;
19583               default:
19584                 jj_la1[254] = jj_gen;
19585                 jj_consume_token(-1);
19586                 throw new ParseException();
19587               }
19588             }
19589           }
19590         }
19591       }
19592    jjtree.closeNodeScope(jjtn000, true);
19593    jjtc000 = false;
19594  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
19595     } catch (Throwable jjte000) {
19596   if (jjtc000) {
19597     jjtree.clearNodeScope(jjtn000);
19598     jjtc000 = false;
19599   } else {
19600     jjtree.popNode();
19601   }
19602   if (jjte000 instanceof RuntimeException) {
19603     {if (true) throw (RuntimeException)jjte000;}
19604   }
19605   if (jjte000 instanceof ParseException) {
19606     {if (true) throw (ParseException)jjte000;}
19607   }
19608   {if (true) throw (Error)jjte000;}
19609     } finally {
19610   if (jjtc000) {
19611     jjtree.closeNodeScope(jjtn000, true);
19612   }
19613     }
19614     throw new Error("Missing return statement in function");
19615   }
19616 
19617   final public ASTPrimarySuffix PrimarySuffix() throws ParseException {
19618  /*@bgen(jjtree) PrimarySuffix */
19619   ASTPrimarySuffix jjtn000 = new ASTPrimarySuffix(this, JJTPRIMARYSUFFIX);
19620   boolean jjtc000 = true;
19621   jjtree.openNodeScope(jjtn000);PLSQLNode suffixNode = null ; PLSQLNode arguments = null; StringBuilder sb = new StringBuilder() ;
19622     try {
19623       switch (jj_nt.kind) {
19624       case 3:
19625         jj_consume_token(3);
19626          sb.append(".");
19627         suffixNode = QualifiedID();
19628                                                            sb.append(suffixNode.toString()) ;
19629         break;
19630       case 2:
19631         jj_consume_token(2);
19632          sb.append("@");
19633         suffixNode = QualifiedID();
19634                                                            sb.append(suffixNode.toString()) ;
19635         break;
19636       case AT:
19637         jj_consume_token(AT);
19638           sb.append(" "); sb.append(token.image.toUpperCase());
19639         switch (jj_nt.kind) {
19640         case LOCAL:
19641           jj_consume_token(LOCAL);
19642                       sb.append(" "); sb.append(token.image.toUpperCase());
19643           break;
19644         case TIME:
19645           jj_consume_token(TIME);
19646           jj_consume_token(ZONE);
19647                                sb.append(" TIME ZONE");
19648           switch (jj_nt.kind) {
19649           case DBTIMEZONE:
19650             jj_consume_token(DBTIMEZONE);
19651                                   sb.append(" "); sb.append(token.image.toUpperCase());
19652             break;
19653           case SESSIONTIMEZONE:
19654             jj_consume_token(SESSIONTIMEZONE);
19655                                        sb.append(" "); sb.append(token.image.toUpperCase());
19656             break;
19657           case STRING_LITERAL:
19658             suffixNode = StringLiteral();
19659                                                   sb.append(" "); sb.append(suffixNode.toString());
19660             break;
19661           case 5:
19662           case 16:
19663           case 17:
19664           case REPLACE:
19665           case DEFINER:
19666           case CURRENT_USER:
19667           case LANGUAGE:
19668           case ADD:
19669           case AGGREGATE:
19670           case ARRAY:
19671           case AT:
19672           case ATTRIBUTE:
19673           case AUTHID:
19674           case BODY:
19675           case BULK:
19676           case BYTE:
19677           case CASCADE:
19678           case CASE:
19679           case CLOSE:
19680           case COALESCE:
19681           case COLLECT:
19682           case COLUMN:
19683           case COMMENT:
19684           case COMMIT:
19685           case CONSTRUCTOR:
19686           case CONTINUE:
19687           case CONVERT:
19688           case CURRENT:
19689           case CURSOR:
19690           case DATA:
19691           case DATE:
19692           case DAY:
19693           case DISABLE:
19694           case EDITIONABLE:
19695           case ELEMENT:
19696           case ENABLE:
19697           case ESCAPE:
19698           case EXCEPT:
19699           case EXCEPTIONS:
19700           case EXIT:
19701           case EXTERNAL:
19702           case EXTENDS:
19703           case EXTRACT:
19704           case FALSE:
19705           case FINAL:
19706           case FORCE:
19707           case FUNCTION:
19708           case GLOBAL:
19709           case HASH:
19710           case HEAP:
19711           case HOUR:
19712           case IMMEDIATE:
19713           case INDICES:
19714           case INDEXTYPE:
19715           case INDICATOR:
19716           case INSTANTIABLE:
19717           case INTERVAL:
19718           case INVALIDATE:
19719           case ISOLATION:
19720           case JAVA:
19721           case LEVEL:
19722           case LIMIT:
19723           case LOOP:
19724           case MAP:
19725           case MAX:
19726           case MEMBER:
19727           case MERGE:
19728           case MIN:
19729           case MINUTE:
19730           case MLSLABEL:
19731           case MODIFY:
19732           case MOD:
19733           case MONTH:
19734           case NATURAL:
19735           case NEW:
19736           case NEW_DOT:
19737           case NO:
19738           case NONEDITIONABLE:
19739           case NOT:
19740           case NULL:
19741           case NULLIF:
19742           case OBJECT:
19743           case OID:
19744           case OPAQUE:
19745           case OPEN:
19746           case OPERATOR:
19747           case ORGANIZATION:
19748           case OTHERS:
19749           case OVERRIDING:
19750           case PACKAGE:
19751           case PARTITION:
19752           case PRESERVE:
19753           case PRIVATE:
19754           case PROCEDURE:
19755           case RANGE:
19756           case RAW:
19757           case REAL:
19758           case RECORD:
19759           case REF:
19760           case RELEASE:
19761           case RELIES_ON:
19762           case RENAME:
19763           case RESULT:
19764           case RETURN:
19765           case RETURNING:
19766           case REVERSE:
19767           case ROLLBACK:
19768           case ROW:
19769           case ROWS:
19770           case ROWID:
19771           case ROWNUM:
19772           case SAVE:
19773           case SAVEPOINT:
19774           case SECOND:
19775           case SELECT:
19776           case SELF:
19777           case SET:
19778           case SPACE:
19779           case SQL:
19780           case SQLCODE:
19781           case SQLERRM:
19782           case STATIC:
19783           case SUBTYPE:
19784           case SUBSTITUTABLE:
19785           case SUCCESSFUL:
19786           case SYSDATE:
19787           case SYS_REFCURSOR:
19788           case TEMPORARY:
19789           case TIME:
19790           case TIMESTAMP:
19791           case TIMEZONE_REGION:
19792           case TIMEZONE_ABBR:
19793           case TIMEZONE_MINUTE:
19794           case TIMEZONE_HOUR:
19795           case TRANSACTION:
19796           case TRUE:
19797           case TYPE:
19798           case UNDER:
19799           case USING:
19800           case YES:
19801           case SHOW:
19802           case A:
19803           case DOUBLE:
19804           case DEC:
19805           case PRECISION:
19806           case INT:
19807           case NUMERIC:
19808           case NCHAR:
19809           case NVARCHAR2:
19810           case STRING:
19811           case UROWID:
19812           case VARRAY:
19813           case VARYING:
19814           case BFILE:
19815           case BLOB:
19816           case CLOB:
19817           case NCLOB:
19818           case YEAR:
19819           case LOCAL:
19820           case WITH:
19821           case ZONE:
19822           case CHARACTER:
19823           case AFTER:
19824           case BEFORE:
19825           case OLD:
19826           case PARENT:
19827           case CC_IF:
19828           case ANALYZE:
19829           case ASSOCIATE:
19830           case AUDIT:
19831           case COMPOUND:
19832           case DATABASE:
19833           case CALL:
19834           case DDL:
19835           case DISASSOCIATE:
19836           case EACH:
19837           case FOLLOWS:
19838           case LOGOFF:
19839           case LOGON:
19840           case NESTED:
19841           case NOAUDIT:
19842           case SCHEMA:
19843           case SERVERERROR:
19844           case SHUTDOWN:
19845           case STARTUP:
19846           case STATEMENT:
19847           case STATISTICS:
19848           case SUSPEND:
19849           case TRUNCATE:
19850           case WRAPPED:
19851           case LIBRARY:
19852           case NAME:
19853           case STRUCT:
19854           case CONTEXT:
19855           case PARAMETERS:
19856           case LENGTH:
19857           case TDO:
19858           case MAXLEN:
19859           case CHARSETID:
19860           case CHARSETFORM:
19861           case ACCEPT:
19862           case ACCESSIBLE:
19863           case COPY:
19864           case DEFINE:
19865           case DISCONNECT:
19866           case HOST:
19867           case PRINT:
19868           case QUIT:
19869           case REMARK:
19870           case UNDEFINE:
19871           case VARIABLE:
19872           case WHENEVER:
19873           case ATTACH:
19874           case CAST:
19875           case TREAT:
19876           case TRIM:
19877           case LEFT:
19878           case RIGHT:
19879           case BOTH:
19880           case EMPTY:
19881           case MULTISET:
19882           case SUBMULTISET:
19883           case LEADING:
19884           case TRAILING:
19885           case CHAR_CS:
19886           case NCHAR_CS:
19887           case AUTHENTICATED:
19888           case LINK:
19889           case SHARED:
19890           case DIRECTORY:
19891           case USER:
19892           case IDENTIFIER:
19893           case UNSIGNED_NUMERIC_LITERAL:
19894           case CHARACTER_LITERAL:
19895           case QUOTED_LITERAL:
19896             suffixNode = Expression();
19897                                                sb.append(" "); sb.append(suffixNode.toString());
19898             break;
19899           default:
19900             jj_la1[255] = jj_gen;
19901             jj_consume_token(-1);
19902             throw new ParseException();
19903           }
19904           break;
19905         default:
19906           jj_la1[256] = jj_gen;
19907           jj_consume_token(-1);
19908           throw new ParseException();
19909         }
19910         break;
19911       case 5:
19912         arguments = Arguments();
19913                                sb.append(arguments) ;
19914         break;
19915       default:
19916         jj_la1[257] = jj_gen;
19917         jj_consume_token(-1);
19918         throw new ParseException();
19919       }
19920    jjtree.closeNodeScope(jjtn000, true);
19921    jjtc000 = false;
19922  jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
19923     } catch (Throwable jjte000) {
19924     if (jjtc000) {
19925       jjtree.clearNodeScope(jjtn000);
19926       jjtc000 = false;
19927     } else {
19928       jjtree.popNode();
19929     }
19930     if (jjte000 instanceof RuntimeException) {
19931       {if (true) throw (RuntimeException)jjte000;}
19932     }
19933     if (jjte000 instanceof ParseException) {
19934       {if (true) throw (ParseException)jjte000;}
19935     }
19936     {if (true) throw (Error)jjte000;}
19937     } finally {
19938     if (jjtc000) {
19939       jjtree.closeNodeScope(jjtn000, true);
19940     }
19941     }
19942     throw new Error("Missing return statement in function");
19943   }
19944 
19945   final public ASTLiteral Literal() throws ParseException {
19946  /*@bgen(jjtree) Literal */
19947  ASTLiteral jjtn000 = new ASTLiteral(this, JJTLITERAL);
19948  boolean jjtc000 = true;
19949  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
19950  Token t = null ;
19951     try {
19952       switch (jj_nt.kind) {
19953       case UNSIGNED_NUMERIC_LITERAL:
19954         simpleNode = NumericLiteral();
19955         break;
19956       case CHARACTER_LITERAL:
19957         t = jj_consume_token(CHARACTER_LITERAL);
19958         break;
19959       case STRING_LITERAL:
19960         //<STRING_LITERAL> {literal = token.toString(); }
19961           simpleNode = StringLiteral();
19962         break;
19963       case FALSE:
19964       case TRUE:
19965         simpleNode = BooleanLiteral();
19966         break;
19967       case NULL:
19968         simpleNode = NullLiteral();
19969         break;
19970       case DATE:
19971       case INTERVAL:
19972       case TIMESTAMP:
19973         simpleNode = DateTimeLiteral();
19974         break;
19975       default:
19976         jj_la1[258] = jj_gen;
19977         jj_consume_token(-1);
19978         throw new ParseException();
19979       }
19980    jjtree.closeNodeScope(jjtn000, true);
19981    jjtc000 = false;
19982    if (null != simpleNode)
19983    {
19984      jjtn000.setImage( simpleNode.getImage() ) ;
19985    }
19986    else if (null != t)
19987    {
19988      jjtn000.setImage( t.image ) ;
19989    }
19990    {if (true) return jjtn000 ;}
19991     } catch (Throwable jjte000) {
19992     if (jjtc000) {
19993       jjtree.clearNodeScope(jjtn000);
19994       jjtc000 = false;
19995     } else {
19996       jjtree.popNode();
19997     }
19998     if (jjte000 instanceof RuntimeException) {
19999       {if (true) throw (RuntimeException)jjte000;}
20000     }
20001     if (jjte000 instanceof ParseException) {
20002       {if (true) throw (ParseException)jjte000;}
20003     }
20004     {if (true) throw (Error)jjte000;}
20005     } finally {
20006     if (jjtc000) {
20007       jjtree.closeNodeScope(jjtn000, true);
20008     }
20009     }
20010     throw new Error("Missing return statement in function");
20011   }
20012 
20013   final public ASTStringLiteral StringLiteral() throws ParseException {
20014  /*@bgen(jjtree) StringLiteral */
20015         ASTStringLiteral jjtn000 = new ASTStringLiteral(this, JJTSTRINGLITERAL);
20016         boolean jjtc000 = true;
20017         jjtree.openNodeScope(jjtn000);Token thisToken = null;
20018         StringBuilder literal = new StringBuilder() ;
20019         char startDelimiter ;
20020         char endDelimiter ;
20021         String terminator = null;
20022     try {
20023       thisToken = jj_consume_token(STRING_LITERAL);
20024    literal.append(thisToken.image);
20025    /*
20026    This might be Q-Quoted string and this might be only a partial string
20027    The token will only match up to the first single quote.
20028    The code below appends any remaining part, theh returns the complete string
20029    */
20030    if (thisToken.image.toUpperCase().startsWith("Q'")
20031        && thisToken.image.length() > 2
20032       )
20033    {
20034    // Get the first token of the string so that the delimiter can be identified
20035 
20036      startDelimiter= thisToken.image.charAt(2) ;
20037      /*
20038      if the start delimiter is one of [, {, <, or (, the end delimiter
20039      is the corresponding closing character
20040      */
20041      switch (startDelimiter)
20042      {
20043       case '<' : endDelimiter = '>' ; break ;
20044       case '{' : endDelimiter = '}' ;  break ;
20045       case '(' : endDelimiter = ')' ;  break ;
20046       case '[' : endDelimiter = ']' ;  break ;
20047       default: endDelimiter = startDelimiter ;
20048      }
20049 
20050      terminator = new String(endDelimiter + "'");
20051      if (!thisToken.image.endsWith(terminator))
20052      {
20053        //Loop until we find atoken that ends with a single-quote precede by the terminator
20054        literal.append(ReadPastNextOccurrence(terminator));
20055      }
20056    }
20057    jjtree.closeNodeScope(jjtn000, true);
20058    jjtc000 = false;
20059    jjtn000.setImage(literal.toString()) ;  jjtn000.value = literal.toString() ; {if (true) return jjtn000 ;}
20060     } finally {
20061    if (jjtc000) {
20062      jjtree.closeNodeScope(jjtn000, true);
20063    }
20064     }
20065     throw new Error("Missing return statement in function");
20066   }
20067 
20068   final public ASTBooleanLiteral BooleanLiteral() throws ParseException {
20069  /*@bgen(jjtree) BooleanLiteral */
20070   ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(this, JJTBOOLEANLITERAL);
20071   boolean jjtc000 = true;
20072   jjtree.openNodeScope(jjtn000);
20073     try {
20074       switch (jj_nt.kind) {
20075       case TRUE:
20076         jj_consume_token(TRUE);
20077         break;
20078       case FALSE:
20079         jj_consume_token(FALSE);
20080         break;
20081       default:
20082         jj_la1[259] = jj_gen;
20083         jj_consume_token(-1);
20084         throw new ParseException();
20085       }
20086     jjtree.closeNodeScope(jjtn000, true);
20087     jjtc000 = false;
20088    jjtn000.setImage(token.image) ;
20089    {if (true) return jjtn000;}
20090     } finally {
20091    if (jjtc000) {
20092      jjtree.closeNodeScope(jjtn000, true);
20093    }
20094     }
20095     throw new Error("Missing return statement in function");
20096   }
20097 
20098   final public ASTNullLiteral NullLiteral() throws ParseException {
20099  /*@bgen(jjtree) NullLiteral */
20100   ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
20101   boolean jjtc000 = true;
20102   jjtree.openNodeScope(jjtn000);
20103     try {
20104       jj_consume_token(NULL);
20105    jjtree.closeNodeScope(jjtn000, true);
20106    jjtc000 = false;
20107   jjtn000.setImage(token.image) ;
20108   {if (true) return jjtn000 ;}
20109     } finally {
20110     if (jjtc000) {
20111       jjtree.closeNodeScope(jjtn000, true);
20112     }
20113     }
20114     throw new Error("Missing return statement in function");
20115   }
20116 
20117   final public ASTMultiSetCondition MultiSetCondition() throws ParseException {
20118  /*@bgen(jjtree) MultiSetCondition */
20119   ASTMultiSetCondition jjtn000 = new ASTMultiSetCondition(this, JJTMULTISETCONDITION);
20120   boolean jjtc000 = true;
20121   jjtree.openNodeScope(jjtn000);
20122     try {
20123       switch (jj_nt.kind) {
20124       case A:
20125         jj_consume_token(A);
20126         jj_consume_token(SET);
20127         break;
20128       case EMPTY:
20129         jj_consume_token(EMPTY);
20130         break;
20131       default:
20132         jj_la1[260] = jj_gen;
20133         jj_consume_token(-1);
20134         throw new ParseException();
20135       }
20136    jjtree.closeNodeScope(jjtn000, true);
20137    jjtc000 = false;
20138   {if (true) return jjtn000;}
20139     } finally {
20140     if (jjtc000) {
20141       jjtree.closeNodeScope(jjtn000, true);
20142     }
20143     }
20144     throw new Error("Missing return statement in function");
20145   }
20146 
20147 /** Recognizes a numeric literal.
20148 * This may look like token, but it isn't. Not atomic enough.
20149 * E.g. "+1" would be valid literal, which make parsing of "i+1" impossible
20150 * (here, we have tokens "i", "+" and "1")
20151 */
20152   final public ASTNumericLiteral NumericLiteral() throws ParseException {
20153  /*@bgen(jjtree) NumericLiteral */
20154  ASTNumericLiteral jjtn000 = new ASTNumericLiteral(this, JJTNUMERICLITERAL);
20155  boolean jjtc000 = true;
20156  jjtree.openNodeScope(jjtn000);Token t = null ;
20157     try {
20158       //Essentially unchanged, as it previouly returned a Token 
20159                       t = jj_consume_token(UNSIGNED_NUMERIC_LITERAL);
20160           jjtree.closeNodeScope(jjtn000, true);
20161           jjtc000 = false;
20162          jjtn000.setImage(t.image) ;
20163          {if (true) return jjtn000;}
20164     } finally {
20165           if (jjtc000) {
20166             jjtree.closeNodeScope(jjtn000, true);
20167           }
20168     }
20169     throw new Error("Missing return statement in function");
20170   }
20171 
20172 /** This cannot be a token because these are valid labels '<< next_msg >>", '<<"OUTER LOOP">>'  
20173 */
20174   final public ASTLabel Label() throws ParseException {
20175  /*@bgen(jjtree) Label */
20176  ASTLabel jjtn000 = new ASTLabel(this, JJTLABEL);
20177  boolean jjtc000 = true;
20178  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20179     try {
20180       jj_consume_token(21);
20181       simpleNode = UnqualifiedID();
20182       jj_consume_token(22);
20183           jjtree.closeNodeScope(jjtn000, true);
20184           jjtc000 = false;
20185         jjtn000.setImage( simpleNode.getImage() ) ;
20186         {if (true) return jjtn000;}
20187     } catch (Throwable jjte000) {
20188           if (jjtc000) {
20189             jjtree.clearNodeScope(jjtn000);
20190             jjtc000 = false;
20191           } else {
20192             jjtree.popNode();
20193           }
20194           if (jjte000 instanceof RuntimeException) {
20195             {if (true) throw (RuntimeException)jjte000;}
20196           }
20197           if (jjte000 instanceof ParseException) {
20198             {if (true) throw (ParseException)jjte000;}
20199           }
20200           {if (true) throw (Error)jjte000;}
20201     } finally {
20202           if (jjtc000) {
20203             jjtree.closeNodeScope(jjtn000, true);
20204           }
20205     }
20206     throw new Error("Missing return statement in function");
20207   }
20208 
20209   final public ASTName Name() throws ParseException {
20210  /*@bgen(jjtree) Name */
20211  ASTName jjtn000 = new ASTName(this, JJTNAME);
20212  boolean jjtc000 = true;
20213  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20214  StringBuilder sb = new StringBuilder();
20215     try {
20216       simpleNode = UnqualifiedID();
20217                                    sb.append(simpleNode.getImage()) ;
20218       label_63:
20219       while (true) {
20220         if (jj_2_56(2)) {
20221           ;
20222         } else {
20223           break label_63;
20224         }
20225         switch (jj_nt.kind) {
20226         case 3:
20227           jj_consume_token(3);
20228             sb.append(".") ;
20229           break;
20230         case 11:
20231           jj_consume_token(11);
20232                                        sb.append("%") ;
20233           break;
20234         default:
20235           jj_la1[261] = jj_gen;
20236           jj_consume_token(-1);
20237           throw new ParseException();
20238         }
20239         //QualifiedID() 
20240             simpleNode = QualifiedID();
20241                                   sb.append(simpleNode.getImage()) ;
20242       }
20243     jjtree.closeNodeScope(jjtn000, true);
20244     jjtc000 = false;
20245   jjtn000.setImage(sb.toString()) ;
20246   {if (true) return jjtn000;}
20247     } catch (Throwable jjte000) {
20248     if (jjtc000) {
20249       jjtree.clearNodeScope(jjtn000);
20250       jjtc000 = false;
20251     } else {
20252       jjtree.popNode();
20253     }
20254     if (jjte000 instanceof RuntimeException) {
20255       {if (true) throw (RuntimeException)jjte000;}
20256     }
20257     if (jjte000 instanceof ParseException) {
20258       {if (true) throw (ParseException)jjte000;}
20259     }
20260     {if (true) throw (Error)jjte000;}
20261     } finally {
20262     if (jjtc000) {
20263       jjtree.closeNodeScope(jjtn000, true);
20264     }
20265     }
20266     throw new Error("Missing return statement in function");
20267   }
20268 
20269   final public ASTQualifiedName QualifiedName() throws ParseException {
20270  /*@bgen(jjtree) QualifiedName */
20271  ASTQualifiedName jjtn000 = new ASTQualifiedName(this, JJTQUALIFIEDNAME);
20272  boolean jjtc000 = true;
20273  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20274  StringBuilder sb = new StringBuilder();
20275     try {
20276       simpleNode = UnqualifiedID();
20277                                         sb.append(simpleNode.getImage()) ;
20278       label_64:
20279       while (true) {
20280         switch (jj_nt.kind) {
20281         case 3:
20282           ;
20283           break;
20284         default:
20285           jj_la1[262] = jj_gen;
20286           break label_64;
20287         }
20288         jj_consume_token(3);
20289         simpleNode = QualifiedID();
20290                                               sb.append(".") ; sb.append(simpleNode.getImage()) ;
20291       }
20292           jjtree.closeNodeScope(jjtn000, true);
20293           jjtc000 = false;
20294          jjtn000.setImage(sb.toString()) ;
20295          {if (true) return jjtn000 ;}
20296     } catch (Throwable jjte000) {
20297           if (jjtc000) {
20298             jjtree.clearNodeScope(jjtn000);
20299             jjtc000 = false;
20300           } else {
20301             jjtree.popNode();
20302           }
20303           if (jjte000 instanceof RuntimeException) {
20304             {if (true) throw (RuntimeException)jjte000;}
20305           }
20306           if (jjte000 instanceof ParseException) {
20307             {if (true) throw (ParseException)jjte000;}
20308           }
20309           {if (true) throw (Error)jjte000;}
20310     } finally {
20311           if (jjtc000) {
20312             jjtree.closeNodeScope(jjtn000, true);
20313           }
20314     }
20315     throw new Error("Missing return statement in function");
20316   }
20317 
20318   final public ASTArguments Arguments() throws ParseException {
20319  /*@bgen(jjtree) Arguments */
20320   ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS);
20321   boolean jjtc000 = true;
20322   jjtree.openNodeScope(jjtn000);
20323     try {
20324       jj_consume_token(5);
20325       switch (jj_nt.kind) {
20326       case 5:
20327       case 16:
20328       case 17:
20329       case REPLACE:
20330       case DEFINER:
20331       case CURRENT_USER:
20332       case LANGUAGE:
20333       case ADD:
20334       case AGGREGATE:
20335       case ARRAY:
20336       case AT:
20337       case ATTRIBUTE:
20338       case AUTHID:
20339       case BODY:
20340       case BULK:
20341       case BYTE:
20342       case CASCADE:
20343       case CASE:
20344       case CLOSE:
20345       case COALESCE:
20346       case COLLECT:
20347       case COLUMN:
20348       case COMMENT:
20349       case COMMIT:
20350       case CONSTRUCTOR:
20351       case CONTINUE:
20352       case CONVERT:
20353       case CURRENT:
20354       case CURSOR:
20355       case DATA:
20356       case DATE:
20357       case DAY:
20358       case DISABLE:
20359       case EDITIONABLE:
20360       case ELEMENT:
20361       case ENABLE:
20362       case ESCAPE:
20363       case EXCEPT:
20364       case EXCEPTIONS:
20365       case EXIT:
20366       case EXTERNAL:
20367       case EXTENDS:
20368       case EXTRACT:
20369       case FALSE:
20370       case FINAL:
20371       case FORCE:
20372       case FUNCTION:
20373       case GLOBAL:
20374       case HASH:
20375       case HEAP:
20376       case HOUR:
20377       case IMMEDIATE:
20378       case INDICES:
20379       case INDEXTYPE:
20380       case INDICATOR:
20381       case INSTANTIABLE:
20382       case INTERVAL:
20383       case INVALIDATE:
20384       case ISOLATION:
20385       case JAVA:
20386       case LEVEL:
20387       case LIMIT:
20388       case LOOP:
20389       case MAP:
20390       case MAX:
20391       case MEMBER:
20392       case MERGE:
20393       case MIN:
20394       case MINUTE:
20395       case MLSLABEL:
20396       case MODIFY:
20397       case MOD:
20398       case MONTH:
20399       case NATURAL:
20400       case NEW:
20401       case NEW_DOT:
20402       case NO:
20403       case NONEDITIONABLE:
20404       case NOT:
20405       case NULL:
20406       case NULLIF:
20407       case OBJECT:
20408       case OID:
20409       case OPAQUE:
20410       case OPEN:
20411       case OPERATOR:
20412       case ORGANIZATION:
20413       case OTHERS:
20414       case OVERRIDING:
20415       case PACKAGE:
20416       case PARTITION:
20417       case PRESERVE:
20418       case PRIVATE:
20419       case PROCEDURE:
20420       case RANGE:
20421       case RAW:
20422       case REAL:
20423       case RECORD:
20424       case REF:
20425       case RELEASE:
20426       case RELIES_ON:
20427       case RENAME:
20428       case RESULT:
20429       case RETURN:
20430       case RETURNING:
20431       case REVERSE:
20432       case ROLLBACK:
20433       case ROW:
20434       case ROWS:
20435       case ROWID:
20436       case ROWNUM:
20437       case SAVE:
20438       case SAVEPOINT:
20439       case SECOND:
20440       case SELECT:
20441       case SELF:
20442       case SET:
20443       case SPACE:
20444       case SQL:
20445       case SQLCODE:
20446       case SQLERRM:
20447       case STATIC:
20448       case SUBTYPE:
20449       case SUBSTITUTABLE:
20450       case SUCCESSFUL:
20451       case SYSDATE:
20452       case SYS_REFCURSOR:
20453       case TEMPORARY:
20454       case TIME:
20455       case TIMESTAMP:
20456       case TIMEZONE_REGION:
20457       case TIMEZONE_ABBR:
20458       case TIMEZONE_MINUTE:
20459       case TIMEZONE_HOUR:
20460       case TRANSACTION:
20461       case TRUE:
20462       case TYPE:
20463       case UNDER:
20464       case USING:
20465       case YES:
20466       case SHOW:
20467       case A:
20468       case DOUBLE:
20469       case DEC:
20470       case PRECISION:
20471       case INT:
20472       case NUMERIC:
20473       case NCHAR:
20474       case NVARCHAR2:
20475       case STRING:
20476       case UROWID:
20477       case VARRAY:
20478       case VARYING:
20479       case BFILE:
20480       case BLOB:
20481       case CLOB:
20482       case NCLOB:
20483       case YEAR:
20484       case LOCAL:
20485       case WITH:
20486       case ZONE:
20487       case CHARACTER:
20488       case AFTER:
20489       case BEFORE:
20490       case OLD:
20491       case PARENT:
20492       case CC_IF:
20493       case ANALYZE:
20494       case ASSOCIATE:
20495       case AUDIT:
20496       case COMPOUND:
20497       case DATABASE:
20498       case CALL:
20499       case DDL:
20500       case DISASSOCIATE:
20501       case EACH:
20502       case FOLLOWS:
20503       case LOGOFF:
20504       case LOGON:
20505       case NESTED:
20506       case NOAUDIT:
20507       case SCHEMA:
20508       case SERVERERROR:
20509       case SHUTDOWN:
20510       case STARTUP:
20511       case STATEMENT:
20512       case STATISTICS:
20513       case SUSPEND:
20514       case TRUNCATE:
20515       case WRAPPED:
20516       case LIBRARY:
20517       case NAME:
20518       case STRUCT:
20519       case CONTEXT:
20520       case PARAMETERS:
20521       case LENGTH:
20522       case TDO:
20523       case MAXLEN:
20524       case CHARSETID:
20525       case CHARSETFORM:
20526       case ACCEPT:
20527       case ACCESSIBLE:
20528       case COPY:
20529       case DEFINE:
20530       case DISCONNECT:
20531       case HOST:
20532       case PRINT:
20533       case QUIT:
20534       case REMARK:
20535       case UNDEFINE:
20536       case VARIABLE:
20537       case WHENEVER:
20538       case ATTACH:
20539       case CAST:
20540       case TREAT:
20541       case TRIM:
20542       case LEFT:
20543       case RIGHT:
20544       case BOTH:
20545       case EMPTY:
20546       case MULTISET:
20547       case SUBMULTISET:
20548       case LEADING:
20549       case TRAILING:
20550       case CHAR_CS:
20551       case NCHAR_CS:
20552       case DBTIMEZONE:
20553       case SESSIONTIMEZONE:
20554       case AUTHENTICATED:
20555       case LINK:
20556       case SHARED:
20557       case DIRECTORY:
20558       case USER:
20559       case IDENTIFIER:
20560       case UNSIGNED_NUMERIC_LITERAL:
20561       case CHARACTER_LITERAL:
20562       case STRING_LITERAL:
20563       case QUOTED_LITERAL:
20564         ArgumentList();
20565         break;
20566       default:
20567         jj_la1[263] = jj_gen;
20568         ;
20569       }
20570       jj_consume_token(7);
20571    jjtree.closeNodeScope(jjtn000, true);
20572    jjtc000 = false;
20573  {if (true) return jjtn000 ;}
20574     } catch (Throwable jjte000) {
20575     if (jjtc000) {
20576       jjtree.clearNodeScope(jjtn000);
20577       jjtc000 = false;
20578     } else {
20579       jjtree.popNode();
20580     }
20581     if (jjte000 instanceof RuntimeException) {
20582       {if (true) throw (RuntimeException)jjte000;}
20583     }
20584     if (jjte000 instanceof ParseException) {
20585       {if (true) throw (ParseException)jjte000;}
20586     }
20587     {if (true) throw (Error)jjte000;}
20588     } finally {
20589     if (jjtc000) {
20590       jjtree.closeNodeScope(jjtn000, true);
20591     }
20592     }
20593     throw new Error("Missing return statement in function");
20594   }
20595 
20596   final public ASTArgumentList ArgumentList() throws ParseException {
20597  /*@bgen(jjtree) ArgumentList */
20598   ASTArgumentList jjtn000 = new ASTArgumentList(this, JJTARGUMENTLIST);
20599   boolean jjtc000 = true;
20600   jjtree.openNodeScope(jjtn000);
20601     try {
20602       Argument();
20603       label_65:
20604       while (true) {
20605         switch (jj_nt.kind) {
20606         case 6:
20607           ;
20608           break;
20609         default:
20610           jj_la1[264] = jj_gen;
20611           break label_65;
20612         }
20613         jj_consume_token(6);
20614         Argument();
20615       }
20616    jjtree.closeNodeScope(jjtn000, true);
20617    jjtc000 = false;
20618  {if (true) return jjtn000 ;}
20619     } catch (Throwable jjte000) {
20620     if (jjtc000) {
20621       jjtree.clearNodeScope(jjtn000);
20622       jjtc000 = false;
20623     } else {
20624       jjtree.popNode();
20625     }
20626     if (jjte000 instanceof RuntimeException) {
20627       {if (true) throw (RuntimeException)jjte000;}
20628     }
20629     if (jjte000 instanceof ParseException) {
20630       {if (true) throw (ParseException)jjte000;}
20631     }
20632     {if (true) throw (Error)jjte000;}
20633     } finally {
20634     if (jjtc000) {
20635       jjtree.closeNodeScope(jjtn000, true);
20636     }
20637     }
20638     throw new Error("Missing return statement in function");
20639   }
20640 
20641   final public ASTArgument Argument() throws ParseException {
20642  /*@bgen(jjtree) Argument */
20643  ASTArgument jjtn000 = new ASTArgument(this, JJTARGUMENT);
20644  boolean jjtc000 = true;
20645  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20646     try {
20647       if (jj_2_57(2)) {
20648         simpleNode = UnqualifiedID();
20649         switch (jj_nt.kind) {
20650         case 23:
20651           jj_consume_token(23);
20652           break;
20653         case AS:
20654           jj_consume_token(AS);
20655           break;
20656         default:
20657           jj_la1[265] = jj_gen;
20658           jj_consume_token(-1);
20659           throw new ParseException();
20660         }
20661       } else {
20662         ;
20663       }
20664       Expression();
20665       switch (jj_nt.kind) {
20666       case USING:
20667         jj_consume_token(USING);
20668         switch (jj_nt.kind) {
20669         case CHAR_CS:
20670           jj_consume_token(CHAR_CS);
20671           break;
20672         case NCHAR_CS:
20673           jj_consume_token(NCHAR_CS);
20674           break;
20675         default:
20676           jj_la1[266] = jj_gen;
20677           jj_consume_token(-1);
20678           throw new ParseException();
20679         }
20680         break;
20681       default:
20682         jj_la1[267] = jj_gen;
20683         ;
20684       }
20685    jjtree.closeNodeScope(jjtn000, true);
20686    jjtc000 = false;
20687  if (null != simpleNode) { jjtn000.setImage(simpleNode.getImage()) ; }
20688  {if (true) return jjtn000 ;}
20689     } catch (Throwable jjte000) {
20690           if (jjtc000) {
20691             jjtree.clearNodeScope(jjtn000);
20692             jjtc000 = false;
20693           } else {
20694             jjtree.popNode();
20695           }
20696           if (jjte000 instanceof RuntimeException) {
20697             {if (true) throw (RuntimeException)jjte000;}
20698           }
20699           if (jjte000 instanceof ParseException) {
20700             {if (true) throw (ParseException)jjte000;}
20701           }
20702           {if (true) throw (Error)jjte000;}
20703     } finally {
20704           if (jjtc000) {
20705             jjtree.closeNodeScope(jjtn000, true);
20706           }
20707     }
20708     throw new Error("Missing return statement in function");
20709   }
20710 
20711 // ============================================================================
20712 // D E C L A R A T I O N S
20713 // ============================================================================
20714   final public ASTVariableOrConstantDeclaration VariableOrConstantDeclaration() throws ParseException {
20715  /*@bgen(jjtree) VariableOrConstantDeclaration */
20716   ASTVariableOrConstantDeclaration jjtn000 = new ASTVariableOrConstantDeclaration(this, JJTVARIABLEORCONSTANTDECLARATION);
20717   boolean jjtc000 = true;
20718   jjtree.openNodeScope(jjtn000);
20719     try {
20720       VariableOrConstantDeclarator();
20721       jj_consume_token(4);
20722     jjtree.closeNodeScope(jjtn000, true);
20723     jjtc000 = false;
20724     {if (true) return jjtn000 ;}
20725     } catch (Throwable jjte000) {
20726     if (jjtc000) {
20727       jjtree.clearNodeScope(jjtn000);
20728       jjtc000 = false;
20729     } else {
20730       jjtree.popNode();
20731     }
20732     if (jjte000 instanceof RuntimeException) {
20733       {if (true) throw (RuntimeException)jjte000;}
20734     }
20735     if (jjte000 instanceof ParseException) {
20736       {if (true) throw (ParseException)jjte000;}
20737     }
20738     {if (true) throw (Error)jjte000;}
20739     } finally {
20740     if (jjtc000) {
20741       jjtree.closeNodeScope(jjtn000, true);
20742     }
20743     }
20744     throw new Error("Missing return statement in function");
20745   }
20746 
20747   final public ASTDatatypeDeclaration DatatypeDeclaration() throws ParseException {
20748  /*@bgen(jjtree) DatatypeDeclaration */
20749  ASTDatatypeDeclaration jjtn000 = new ASTDatatypeDeclaration(this, JJTDATATYPEDECLARATION);
20750  boolean jjtc000 = true;
20751  jjtree.openNodeScope(jjtn000);Token t ;
20752     try {
20753       t = jj_consume_token(IDENTIFIER);
20754     jjtree.closeNodeScope(jjtn000, true);
20755     jjtc000 = false;
20756     jjtn000.setImage(t.image) ;  {if (true) return jjtn000 ;}
20757     } finally {
20758     if (jjtc000) {
20759       jjtree.closeNodeScope(jjtn000, true);
20760     }
20761     }
20762     throw new Error("Missing return statement in function");
20763   }
20764 
20765   final public ASTPragma Pragma() throws ParseException {
20766  /*@bgen(jjtree) Pragma */
20767   ASTPragma jjtn000 = new ASTPragma(this, JJTPRAGMA);
20768   boolean jjtc000 = true;
20769   jjtree.openNodeScope(jjtn000);
20770     try {
20771       jj_consume_token(PRAGMA);
20772       switch (jj_nt.kind) {
20773       case SERIALLY_REUSABLE:
20774         jj_consume_token(SERIALLY_REUSABLE);
20775         break;
20776       case AUTONOMOUS_TRANSACTION:
20777         jj_consume_token(AUTONOMOUS_TRANSACTION);
20778         break;
20779       case TIMESTAMP:
20780         jj_consume_token(TIMESTAMP);
20781         jj_consume_token(5);
20782         StringLiteral();
20783         jj_consume_token(7);
20784         break;
20785       case RESTRICT_REFERENCES:
20786         jj_consume_token(RESTRICT_REFERENCES);
20787         jj_consume_token(5);
20788         ID();
20789         label_66:
20790         while (true) {
20791           jj_consume_token(6);
20792           switch (jj_nt.kind) {
20793           case REPLACE:
20794           case DEFINER:
20795           case CURRENT_USER:
20796           case SERIALLY_REUSABLE:
20797           case RESTRICT_REFERENCES:
20798           case EXCEPTION_INIT:
20799           case AUTONOMOUS_TRANSACTION:
20800           case LANGUAGE:
20801           case ADD:
20802           case AGGREGATE:
20803           case ALL:
20804           case ALTER:
20805           case AND:
20806           case ANY:
20807           case ARRAY:
20808           case AS:
20809           case ASC:
20810           case AT:
20811           case ATTRIBUTE:
20812           case AUTHID:
20813           case AVG:
20814           case BETWEEN:
20815           case BINARY_INTEGER:
20816           case BODY:
20817           case BOOLEAN:
20818           case BULK:
20819           case BY:
20820           case BYTE:
20821           case CASCADE:
20822           case CASE:
20823           case CHAR:
20824           case CHAR_BASE:
20825           case CHECK:
20826           case CLOSE:
20827           case CLUSTER:
20828           case COALESCE:
20829           case COLLECT:
20830           case COLUMN:
20831           case COMMENT:
20832           case COMMIT:
20833           case COMPRESS:
20834           case CONNECT:
20835           case CONSTANT:
20836           case CONSTRUCTOR:
20837           case CONTINUE:
20838           case CONVERT:
20839           case CREATE:
20840           case CURRENT:
20841           case CURRVAL:
20842           case CURSOR:
20843           case DATA:
20844           case DATE:
20845           case DAY:
20846           case DECLARE:
20847           case DECIMAL:
20848           case _DEFAULT:
20849           case DELETE:
20850           case DESC:
20851           case DISABLE:
20852           case DISTINCT:
20853           case DO:
20854           case DROP:
20855           case EDITIONABLE:
20856           case ELEMENT:
20857           case ELSE:
20858           case ELSIF:
20859           case ENABLE:
20860           case ESCAPE:
20861           case EXCEPT:
20862           case EXCEPTION:
20863           case EXCEPTIONS:
20864           case EXCLUSIVE:
20865           case EXECUTE:
20866           case EXISTS:
20867           case EXIT:
20868           case EXTERNAL:
20869           case EXTENDS:
20870           case EXTRACT:
20871           case FALSE:
20872           case FETCH:
20873           case FINAL:
20874           case FLOAT:
20875           case FOR:
20876           case FORALL:
20877           case FORCE:
20878           case FROM:
20879           case FUNCTION:
20880           case GLOBAL:
20881           case GOTO:
20882           case GROUP:
20883           case HASH:
20884           case HAVING:
20885           case HEAP:
20886           case HOUR:
20887           case IF:
20888           case IMMEDIATE:
20889           case IN:
20890           case INDEX:
20891           case INDICES:
20892           case INDEXTYPE:
20893           case INDICATOR:
20894           case INSERT:
20895           case INSTANTIABLE:
20896           case INTEGER:
20897           case INTERFACE:
20898           case INTERSECT:
20899           case INTERVAL:
20900           case INTO:
20901           case INVALIDATE:
20902           case IS:
20903           case ISOLATION:
20904           case JAVA:
20905           case LEVEL:
20906           case LIKE:
20907           case LIMIT:
20908           case LIMITED:
20909           case LOCK:
20910           case LONG:
20911           case LOOP:
20912           case MAP:
20913           case MAX:
20914           case MEMBER:
20915           case MERGE:
20916           case MIN:
20917           case MINUS:
20918           case MINUTE:
20919           case MLSLABEL:
20920           case MODIFY:
20921           case MOD:
20922           case MODE:
20923           case MONTH:
20924           case NATURAL:
20925           case NATURALN:
20926           case NEW:
20927           case NEXTVAL:
20928           case NO:
20929           case NOCOPY:
20930           case NONEDITIONABLE:
20931           case NOT:
20932           case NOWAIT:
20933           case NULL:
20934           case NULLIF:
20935           case NUMBER:
20936           case BFILE_BASE:
20937           case BLOB_BASE:
20938           case CLOB_BASE:
20939           case DATE_BASE:
20940           case NUMBER_BASE:
20941           case OBJECT:
20942           case OCIROWID:
20943           case OF:
20944           case OID:
20945           case ON:
20946           case OPAQUE:
20947           case OPEN:
20948           case OPERATOR:
20949           case OPTION:
20950           case OR:
20951           case ORDER:
20952           case ORGANIZATION:
20953           case OTHERS:
20954           case OUT:
20955           case OVERRIDING:
20956           case PACKAGE:
20957           case PARTITION:
20958           case PCTFREE:
20959           case PLS_INTEGER:
20960           case POSITIVE:
20961           case POSITIVEN:
20962           case PRESERVE:
20963           case PRIOR:
20964           case PROMPT:
20965           case PRIVATE:
20966           case PROCEDURE:
20967           case PUBLIC:
20968           case RAISE:
20969           case RANGE:
20970           case RAW:
20971           case REAL:
20972           case RECORD:
20973           case REF:
20974           case RELEASE:
20975           case RELIES_ON:
20976           case RENAME:
20977           case RESULT:
20978           case RETURN:
20979           case RETURNING:
20980           case REVERSE:
20981           case ROLLBACK:
20982           case ROW:
20983           case ROWS:
20984           case ROWID:
20985           case ROWNUM:
20986           case ROWTYPE:
20987           case SAVE:
20988           case SAVEPOINT:
20989           case SECOND:
20990           case SELECT:
20991           case SELF:
20992           case SEPARATE:
20993           case SET:
20994           case SHARE:
20995           case SMALLINT:
20996           case SPACE:
20997           case SQL:
20998           case SQLCODE:
20999           case SQLERRM:
21000           case START:
21001           case STATIC:
21002           case STDDEV:
21003           case SUBTYPE:
21004           case SUBSTITUTABLE:
21005           case SUCCESSFUL:
21006           case SUM:
21007           case SYNONYM:
21008           case SYSDATE:
21009           case SYS_REFCURSOR:
21010           case TABLE:
21011           case TEMPORARY:
21012           case THEN:
21013           case TIME:
21014           case TIMESTAMP:
21015           case TIMEZONE_REGION:
21016           case TIMEZONE_ABBR:
21017           case TIMEZONE_MINUTE:
21018           case TIMEZONE_HOUR:
21019           case TO:
21020           case TRANSACTION:
21021           case TRIGGER:
21022           case TRUE:
21023           case TYPE:
21024           case UI:
21025           case UNDER:
21026           case USING:
21027           case WHILE:
21028           case YES:
21029           case SHOW:
21030           case A:
21031           case UPDATE:
21032           case VARCHAR:
21033           case VARCHAR2:
21034           case DOUBLE:
21035           case DEC:
21036           case PRECISION:
21037           case INT:
21038           case NUMERIC:
21039           case SIGNTYPE:
21040           case NCHAR:
21041           case NVARCHAR2:
21042           case STRING:
21043           case UROWID:
21044           case VARRAY:
21045           case VARYING:
21046           case BFILE:
21047           case BLOB:
21048           case CLOB:
21049           case NCLOB:
21050           case YEAR:
21051           case LOCAL:
21052           case WITH:
21053           case ZONE:
21054           case CHARACTER:
21055           case AFTER:
21056           case BEFORE:
21057           case OLD:
21058           case PARENT:
21059           case ANALYZE:
21060           case ASSOCIATE:
21061           case AUDIT:
21062           case COMPOUND:
21063           case DATABASE:
21064           case CALL:
21065           case DDL:
21066           case DISASSOCIATE:
21067           case EACH:
21068           case FOLLOWS:
21069           case LOGOFF:
21070           case LOGON:
21071           case NESTED:
21072           case NOAUDIT:
21073           case SCHEMA:
21074           case SERVERERROR:
21075           case SHUTDOWN:
21076           case STARTUP:
21077           case STATEMENT:
21078           case STATISTICS:
21079           case SUSPEND:
21080           case TRUNCATE:
21081           case WRAPPED:
21082           case LIBRARY:
21083           case NAME:
21084           case STRUCT:
21085           case CONTEXT:
21086           case PARAMETERS:
21087           case LENGTH:
21088           case TDO:
21089           case MAXLEN:
21090           case CHARSETID:
21091           case CHARSETFORM:
21092           case ACCEPT:
21093           case ACCESSIBLE:
21094           case COPY:
21095           case DEFINE:
21096           case DISCONNECT:
21097           case HOST:
21098           case PRINT:
21099           case QUIT:
21100           case REMARK:
21101           case UNDEFINE:
21102           case VARIABLE:
21103           case WHENEVER:
21104           case ATTACH:
21105           case CAST:
21106           case TREAT:
21107           case TRIM:
21108           case LEFT:
21109           case RIGHT:
21110           case BOTH:
21111           case EMPTY:
21112           case MULTISET:
21113           case SUBMULTISET:
21114           case LEADING:
21115           case TRAILING:
21116           case CHAR_CS:
21117           case NCHAR_CS:
21118           case DBTIMEZONE:
21119           case SESSIONTIMEZONE:
21120           case AUTHENTICATED:
21121           case LINK:
21122           case SHARED:
21123           case DIRECTORY:
21124           case USER:
21125           case IDENTIFIER:
21126           case QUOTED_LITERAL:
21127           case SQLDATA_CLASS:
21128           case CUSTOMDATUM_CLASS:
21129           case ORADATA_CLASS:
21130           case JAVA_INTERFACE_CLASS:
21131             ID();
21132             break;
21133           case STRING_LITERAL:
21134             StringLiteral();
21135             break;
21136           default:
21137             jj_la1[268] = jj_gen;
21138             jj_consume_token(-1);
21139             throw new ParseException();
21140           }
21141           switch (jj_nt.kind) {
21142           case 6:
21143             ;
21144             break;
21145           default:
21146             jj_la1[269] = jj_gen;
21147             break label_66;
21148           }
21149         }
21150         jj_consume_token(7);
21151         break;
21152       case EXCEPTION_INIT:
21153         jj_consume_token(EXCEPTION_INIT);
21154         jj_consume_token(5);
21155         jj_consume_token(IDENTIFIER);
21156         jj_consume_token(6);
21157         switch (jj_nt.kind) {
21158         case 16:
21159         case 17:
21160           switch (jj_nt.kind) {
21161           case 16:
21162             jj_consume_token(16);
21163             break;
21164           case 17:
21165             jj_consume_token(17);
21166             break;
21167           default:
21168             jj_la1[270] = jj_gen;
21169             jj_consume_token(-1);
21170             throw new ParseException();
21171           }
21172           break;
21173         default:
21174           jj_la1[271] = jj_gen;
21175           ;
21176         }
21177         NumericLiteral();
21178         jj_consume_token(7);
21179         break;
21180       case INTERFACE:
21181         jj_consume_token(INTERFACE);
21182         jj_consume_token(5);
21183         jj_consume_token(IDENTIFIER);
21184         jj_consume_token(6);
21185         ID();
21186         switch (jj_nt.kind) {
21187         case 6:
21188           jj_consume_token(6);
21189           NumericLiteral();
21190           break;
21191         default:
21192           jj_la1[272] = jj_gen;
21193           ;
21194         }
21195         jj_consume_token(7);
21196         break;
21197       case REPLACE:
21198       case DEFINER:
21199       case CURRENT_USER:
21200       case LANGUAGE:
21201       case ADD:
21202       case AGGREGATE:
21203       case ARRAY:
21204       case AT:
21205       case ATTRIBUTE:
21206       case AUTHID:
21207       case BODY:
21208       case BULK:
21209       case BYTE:
21210       case CASCADE:
21211       case CLOSE:
21212       case COALESCE:
21213       case COLLECT:
21214       case COLUMN:
21215       case COMMENT:
21216       case COMMIT:
21217       case CONSTRUCTOR:
21218       case CONTINUE:
21219       case CONVERT:
21220       case CURRENT:
21221       case CURSOR:
21222       case DATA:
21223       case DAY:
21224       case DISABLE:
21225       case EDITIONABLE:
21226       case ELEMENT:
21227       case ENABLE:
21228       case ESCAPE:
21229       case EXCEPT:
21230       case EXCEPTIONS:
21231       case EXIT:
21232       case EXTERNAL:
21233       case EXTENDS:
21234       case EXTRACT:
21235       case FALSE:
21236       case FINAL:
21237       case FORCE:
21238       case FUNCTION:
21239       case GLOBAL:
21240       case HASH:
21241       case HEAP:
21242       case HOUR:
21243       case IMMEDIATE:
21244       case INDICES:
21245       case INDEXTYPE:
21246       case INDICATOR:
21247       case INSTANTIABLE:
21248       case INTERVAL:
21249       case INVALIDATE:
21250       case ISOLATION:
21251       case JAVA:
21252       case LEVEL:
21253       case LIMIT:
21254       case LOOP:
21255       case MAP:
21256       case MAX:
21257       case MEMBER:
21258       case MERGE:
21259       case MIN:
21260       case MINUTE:
21261       case MLSLABEL:
21262       case MODIFY:
21263       case MOD:
21264       case MONTH:
21265       case NATURAL:
21266       case NEW:
21267       case NO:
21268       case NONEDITIONABLE:
21269       case NULLIF:
21270       case OBJECT:
21271       case OID:
21272       case OPAQUE:
21273       case OPEN:
21274       case OPERATOR:
21275       case ORGANIZATION:
21276       case OTHERS:
21277       case OVERRIDING:
21278       case PACKAGE:
21279       case PARTITION:
21280       case PRESERVE:
21281       case PRIVATE:
21282       case PROCEDURE:
21283       case RANGE:
21284       case RAW:
21285       case REAL:
21286       case RECORD:
21287       case REF:
21288       case RELEASE:
21289       case RELIES_ON:
21290       case RENAME:
21291       case RESULT:
21292       case RETURN:
21293       case RETURNING:
21294       case REVERSE:
21295       case ROLLBACK:
21296       case ROW:
21297       case ROWS:
21298       case ROWID:
21299       case ROWNUM:
21300       case SAVE:
21301       case SAVEPOINT:
21302       case SECOND:
21303       case SELF:
21304       case SET:
21305       case SPACE:
21306       case SQL:
21307       case SQLCODE:
21308       case SQLERRM:
21309       case STATIC:
21310       case SUBTYPE:
21311       case SUBSTITUTABLE:
21312       case SUCCESSFUL:
21313       case SYSDATE:
21314       case SYS_REFCURSOR:
21315       case TEMPORARY:
21316       case TIME:
21317       case TIMEZONE_REGION:
21318       case TIMEZONE_ABBR:
21319       case TIMEZONE_MINUTE:
21320       case TIMEZONE_HOUR:
21321       case TRANSACTION:
21322       case TRUE:
21323       case TYPE:
21324       case UNDER:
21325       case USING:
21326       case YES:
21327       case SHOW:
21328       case A:
21329       case DOUBLE:
21330       case DEC:
21331       case PRECISION:
21332       case INT:
21333       case NUMERIC:
21334       case NCHAR:
21335       case NVARCHAR2:
21336       case STRING:
21337       case UROWID:
21338       case VARRAY:
21339       case VARYING:
21340       case BFILE:
21341       case BLOB:
21342       case CLOB:
21343       case NCLOB:
21344       case YEAR:
21345       case LOCAL:
21346       case ZONE:
21347       case CHARACTER:
21348       case AFTER:
21349       case BEFORE:
21350       case OLD:
21351       case PARENT:
21352       case ANALYZE:
21353       case ASSOCIATE:
21354       case AUDIT:
21355       case COMPOUND:
21356       case DATABASE:
21357       case CALL:
21358       case DDL:
21359       case DISASSOCIATE:
21360       case EACH:
21361       case FOLLOWS:
21362       case LOGOFF:
21363       case LOGON:
21364       case NESTED:
21365       case NOAUDIT:
21366       case SCHEMA:
21367       case SERVERERROR:
21368       case SHUTDOWN:
21369       case STARTUP:
21370       case STATEMENT:
21371       case STATISTICS:
21372       case SUSPEND:
21373       case TRUNCATE:
21374       case WRAPPED:
21375       case LIBRARY:
21376       case NAME:
21377       case STRUCT:
21378       case CONTEXT:
21379       case PARAMETERS:
21380       case LENGTH:
21381       case TDO:
21382       case MAXLEN:
21383       case CHARSETID:
21384       case CHARSETFORM:
21385       case ACCEPT:
21386       case ACCESSIBLE:
21387       case COPY:
21388       case DEFINE:
21389       case DISCONNECT:
21390       case HOST:
21391       case PRINT:
21392       case QUIT:
21393       case REMARK:
21394       case UNDEFINE:
21395       case VARIABLE:
21396       case WHENEVER:
21397       case ATTACH:
21398       case CAST:
21399       case TREAT:
21400       case TRIM:
21401       case LEFT:
21402       case RIGHT:
21403       case BOTH:
21404       case EMPTY:
21405       case MULTISET:
21406       case SUBMULTISET:
21407       case LEADING:
21408       case TRAILING:
21409       case CHAR_CS:
21410       case NCHAR_CS:
21411       case DBTIMEZONE:
21412       case SESSIONTIMEZONE:
21413       case AUTHENTICATED:
21414       case LINK:
21415       case SHARED:
21416       case DIRECTORY:
21417       case USER:
21418       case IDENTIFIER:
21419       case QUOTED_LITERAL:
21420         QualifiedName();
21421         jj_consume_token(5);
21422         ReadPastNextOccurrence(")");
21423         break;
21424       default:
21425         jj_la1[273] = jj_gen;
21426         jj_consume_token(-1);
21427         throw new ParseException();
21428       }
21429       jj_consume_token(4);
21430         jjtree.closeNodeScope(jjtn000, true);
21431         jjtc000 = false;
21432         {if (true) return jjtn000 ;}
21433     } catch (Throwable jjte000) {
21434           if (jjtc000) {
21435             jjtree.clearNodeScope(jjtn000);
21436             jjtc000 = false;
21437           } else {
21438             jjtree.popNode();
21439           }
21440           if (jjte000 instanceof RuntimeException) {
21441             {if (true) throw (RuntimeException)jjte000;}
21442           }
21443           if (jjte000 instanceof ParseException) {
21444             {if (true) throw (ParseException)jjte000;}
21445           }
21446           {if (true) throw (Error)jjte000;}
21447     } finally {
21448           if (jjtc000) {
21449             jjtree.closeNodeScope(jjtn000, true);
21450           }
21451     }
21452     throw new Error("Missing return statement in function");
21453   }
21454 
21455   final public ASTExceptionDeclaration ExceptionDeclaration() throws ParseException {
21456  /*@bgen(jjtree) ExceptionDeclaration */
21457  ASTExceptionDeclaration jjtn000 = new ASTExceptionDeclaration(this, JJTEXCEPTIONDECLARATION);
21458  boolean jjtc000 = true;
21459  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21460     try {
21461       simpleNode = ID();
21462       jj_consume_token(EXCEPTION);
21463       jj_consume_token(4);
21464         jjtree.closeNodeScope(jjtn000, true);
21465         jjtc000 = false;
21466         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
21467     } catch (Throwable jjte000) {
21468           if (jjtc000) {
21469             jjtree.clearNodeScope(jjtn000);
21470             jjtc000 = false;
21471           } else {
21472             jjtree.popNode();
21473           }
21474           if (jjte000 instanceof RuntimeException) {
21475             {if (true) throw (RuntimeException)jjte000;}
21476           }
21477           if (jjte000 instanceof ParseException) {
21478             {if (true) throw (ParseException)jjte000;}
21479           }
21480           {if (true) throw (Error)jjte000;}
21481     } finally {
21482           if (jjtc000) {
21483             jjtree.closeNodeScope(jjtn000, true);
21484           }
21485     }
21486     throw new Error("Missing return statement in function");
21487   }
21488 
21489   final public ASTParallelClause ParallelClause() throws ParseException {
21490  /*@bgen(jjtree) ParallelClause */
21491   ASTParallelClause jjtn000 = new ASTParallelClause(this, JJTPARALLELCLAUSE);
21492   boolean jjtc000 = true;
21493   jjtree.openNodeScope(jjtn000);
21494     try {
21495       jj_consume_token(5);
21496       jj_consume_token(PARTITION);
21497       ID();
21498       jj_consume_token(BY);
21499       switch (jj_nt.kind) {
21500       case ANY:
21501         jj_consume_token(ANY);
21502         break;
21503       case HASH:
21504       case RANGE:
21505         switch (jj_nt.kind) {
21506         case HASH:
21507           jj_consume_token(HASH);
21508           break;
21509         case RANGE:
21510           jj_consume_token(RANGE);
21511           break;
21512         default:
21513           jj_la1[274] = jj_gen;
21514           jj_consume_token(-1);
21515           throw new ParseException();
21516         }
21517         jj_consume_token(5);
21518         ID();
21519         label_67:
21520         while (true) {
21521           switch (jj_nt.kind) {
21522           case 6:
21523             ;
21524             break;
21525           default:
21526             jj_la1[275] = jj_gen;
21527             break label_67;
21528           }
21529           jj_consume_token(6);
21530           ID();
21531         }
21532         jj_consume_token(7);
21533         break;
21534       default:
21535         jj_la1[276] = jj_gen;
21536         jj_consume_token(-1);
21537         throw new ParseException();
21538       }
21539       jj_consume_token(7);
21540       switch (jj_nt.kind) {
21541       case CLUSTER:
21542       case ORDER:
21543         switch (jj_nt.kind) {
21544         case ORDER:
21545           jj_consume_token(ORDER);
21546           break;
21547         case CLUSTER:
21548           jj_consume_token(CLUSTER);
21549           break;
21550         default:
21551           jj_la1[277] = jj_gen;
21552           jj_consume_token(-1);
21553           throw new ParseException();
21554         }
21555         jj_consume_token(BY);
21556         jj_consume_token(5);
21557         ID();
21558         label_68:
21559         while (true) {
21560           switch (jj_nt.kind) {
21561           case 6:
21562             ;
21563             break;
21564           default:
21565             jj_la1[278] = jj_gen;
21566             break label_68;
21567           }
21568           jj_consume_token(6);
21569           ID();
21570         }
21571         jj_consume_token(7);
21572         break;
21573       default:
21574         jj_la1[279] = jj_gen;
21575         ;
21576       }
21577         jjtree.closeNodeScope(jjtn000, true);
21578         jjtc000 = false;
21579         {if (true) return jjtn000 ;}
21580     } catch (Throwable jjte000) {
21581       if (jjtc000) {
21582         jjtree.clearNodeScope(jjtn000);
21583         jjtc000 = false;
21584       } else {
21585         jjtree.popNode();
21586       }
21587       if (jjte000 instanceof RuntimeException) {
21588         {if (true) throw (RuntimeException)jjte000;}
21589       }
21590       if (jjte000 instanceof ParseException) {
21591         {if (true) throw (ParseException)jjte000;}
21592       }
21593       {if (true) throw (Error)jjte000;}
21594     } finally {
21595       if (jjtc000) {
21596         jjtree.closeNodeScope(jjtn000, true);
21597       }
21598     }
21599     throw new Error("Missing return statement in function");
21600   }
21601 
21602   final public ASTAccessibleByClause AccessibleByClause() throws ParseException {
21603  /*@bgen(jjtree) AccessibleByClause */
21604   ASTAccessibleByClause jjtn000 = new ASTAccessibleByClause(this, JJTACCESSIBLEBYCLAUSE);
21605   boolean jjtc000 = true;
21606   jjtree.openNodeScope(jjtn000);
21607     try {
21608       jj_consume_token(ACCESSIBLE);
21609       jj_consume_token(BY);
21610       jj_consume_token(5);
21611       switch (jj_nt.kind) {
21612       case FUNCTION:
21613       case PACKAGE:
21614       case PROCEDURE:
21615       case TRIGGER:
21616       case TYPE:
21617         switch (jj_nt.kind) {
21618         case FUNCTION:
21619           jj_consume_token(FUNCTION);
21620           break;
21621         case PROCEDURE:
21622           jj_consume_token(PROCEDURE);
21623           break;
21624         case PACKAGE:
21625           jj_consume_token(PACKAGE);
21626           break;
21627         case TRIGGER:
21628           jj_consume_token(TRIGGER);
21629           break;
21630         case TYPE:
21631           jj_consume_token(TYPE);
21632           break;
21633         default:
21634           jj_la1[280] = jj_gen;
21635           jj_consume_token(-1);
21636           throw new ParseException();
21637         }
21638         break;
21639       default:
21640         jj_la1[281] = jj_gen;
21641         ;
21642       }
21643       QualifiedName();
21644       label_69:
21645       while (true) {
21646         switch (jj_nt.kind) {
21647         case 6:
21648           ;
21649           break;
21650         default:
21651           jj_la1[282] = jj_gen;
21652           break label_69;
21653         }
21654         jj_consume_token(6);
21655         switch (jj_nt.kind) {
21656         case FUNCTION:
21657         case PACKAGE:
21658         case PROCEDURE:
21659         case TRIGGER:
21660         case TYPE:
21661           switch (jj_nt.kind) {
21662           case FUNCTION:
21663             jj_consume_token(FUNCTION);
21664             break;
21665           case PROCEDURE:
21666             jj_consume_token(PROCEDURE);
21667             break;
21668           case PACKAGE:
21669             jj_consume_token(PACKAGE);
21670             break;
21671           case TRIGGER:
21672             jj_consume_token(TRIGGER);
21673             break;
21674           case TYPE:
21675             jj_consume_token(TYPE);
21676             break;
21677           default:
21678             jj_la1[283] = jj_gen;
21679             jj_consume_token(-1);
21680             throw new ParseException();
21681           }
21682           break;
21683         default:
21684           jj_la1[284] = jj_gen;
21685           ;
21686         }
21687         QualifiedName();
21688       }
21689       jj_consume_token(7);
21690         jjtree.closeNodeScope(jjtn000, true);
21691         jjtc000 = false;
21692         {if (true) return jjtn000 ;}
21693     } catch (Throwable jjte000) {
21694       if (jjtc000) {
21695         jjtree.clearNodeScope(jjtn000);
21696         jjtc000 = false;
21697       } else {
21698         jjtree.popNode();
21699       }
21700       if (jjte000 instanceof RuntimeException) {
21701         {if (true) throw (RuntimeException)jjte000;}
21702       }
21703       if (jjte000 instanceof ParseException) {
21704         {if (true) throw (ParseException)jjte000;}
21705       }
21706       {if (true) throw (Error)jjte000;}
21707     } finally {
21708       if (jjtc000) {
21709         jjtree.closeNodeScope(jjtn000, true);
21710       }
21711     }
21712     throw new Error("Missing return statement in function");
21713   }
21714 
21715 // Copyright (C) 2002 Albert Tumanov
21716 
21717 /**
21718  * 2006-05-10 - Matthias Hendler - merged SIV and sourceforge sources
21719  */
21720 
21721 // SRT *
21722   final public ASTTable Table() throws ParseException {
21723  /*@bgen(jjtree) Table */
21724   ASTTable jjtn000 = new ASTTable(this, JJTTABLE);
21725   boolean jjtc000 = true;
21726   jjtree.openNodeScope(jjtn000);
21727     try {
21728       jj_consume_token(CREATE);
21729       switch (jj_nt.kind) {
21730       case GLOBAL:
21731         jj_consume_token(GLOBAL);
21732         jj_consume_token(TEMPORARY);
21733         break;
21734       default:
21735         jj_la1[285] = jj_gen;
21736         ;
21737       }
21738       jj_consume_token(TABLE);
21739       ObjectNameDeclaration();
21740       jj_consume_token(5);
21741       TableColumn();
21742       label_70:
21743       while (true) {
21744         switch (jj_nt.kind) {
21745         case 6:
21746           ;
21747           break;
21748         default:
21749           jj_la1[286] = jj_gen;
21750           break label_70;
21751         }
21752         jj_consume_token(6);
21753         TableColumn();
21754       }
21755       jj_consume_token(7);
21756       if (jj_2_58(2)) {
21757         jj_consume_token(ON);
21758         jj_consume_token(COMMIT);
21759         switch (jj_nt.kind) {
21760         case DELETE:
21761           jj_consume_token(DELETE);
21762           break;
21763         case PRESERVE:
21764           jj_consume_token(PRESERVE);
21765           break;
21766         default:
21767           jj_la1[287] = jj_gen;
21768           jj_consume_token(-1);
21769           throw new ParseException();
21770         }
21771         jj_consume_token(ROWS);
21772       } else {
21773         ;
21774       }
21775       switch (jj_nt.kind) {
21776       case 4:
21777         jj_consume_token(4);
21778         break;
21779       default:
21780         jj_la1[288] = jj_gen;
21781         ;
21782       }
21783         jjtree.closeNodeScope(jjtn000, true);
21784         jjtc000 = false;
21785         {if (true) return jjtn000 ;}
21786     } catch (Throwable jjte000) {
21787     if (jjtc000) {
21788       jjtree.clearNodeScope(jjtn000);
21789       jjtc000 = false;
21790     } else {
21791       jjtree.popNode();
21792     }
21793     if (jjte000 instanceof RuntimeException) {
21794       {if (true) throw (RuntimeException)jjte000;}
21795     }
21796     if (jjte000 instanceof ParseException) {
21797       {if (true) throw (ParseException)jjte000;}
21798     }
21799     {if (true) throw (Error)jjte000;}
21800     } finally {
21801     if (jjtc000) {
21802       jjtree.closeNodeScope(jjtn000, true);
21803     }
21804     }
21805     throw new Error("Missing return statement in function");
21806   }
21807 
21808   final public ASTTableColumn TableColumn() throws ParseException {
21809  /*@bgen(jjtree) TableColumn */
21810   ASTTableColumn jjtn000 = new ASTTableColumn(this, JJTTABLECOLUMN);
21811   boolean jjtc000 = true;
21812   jjtree.openNodeScope(jjtn000);
21813     try {
21814       ID();
21815       Datatype();
21816       switch (jj_nt.kind) {
21817       case _DEFAULT:
21818         jj_consume_token(_DEFAULT);
21819         Expression();
21820         break;
21821       default:
21822         jj_la1[289] = jj_gen;
21823         ;
21824       }
21825       switch (jj_nt.kind) {
21826       case NOT:
21827       case NULL:
21828         switch (jj_nt.kind) {
21829         case NOT:
21830           jj_consume_token(NOT);
21831           break;
21832         default:
21833           jj_la1[290] = jj_gen;
21834           ;
21835         }
21836         jj_consume_token(NULL);
21837         break;
21838       default:
21839         jj_la1[291] = jj_gen;
21840         ;
21841       }
21842         jjtree.closeNodeScope(jjtn000, true);
21843         jjtc000 = false;
21844         {if (true) return jjtn000 ;}
21845     } catch (Throwable jjte000) {
21846     if (jjtc000) {
21847       jjtree.clearNodeScope(jjtn000);
21848       jjtc000 = false;
21849     } else {
21850       jjtree.popNode();
21851     }
21852     if (jjte000 instanceof RuntimeException) {
21853       {if (true) throw (RuntimeException)jjte000;}
21854     }
21855     if (jjte000 instanceof ParseException) {
21856       {if (true) throw (ParseException)jjte000;}
21857     }
21858     {if (true) throw (Error)jjte000;}
21859     } finally {
21860     if (jjtc000) {
21861       jjtree.closeNodeScope(jjtn000, true);
21862     }
21863     }
21864     throw new Error("Missing return statement in function");
21865   }
21866 
21867   final public ASTView View() throws ParseException {
21868  /*@bgen(jjtree) View */
21869  ASTView jjtn000 = new ASTView(this, JJTVIEW);
21870  boolean jjtc000 = true;
21871  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21872     try {
21873       jj_consume_token(CREATE);
21874       switch (jj_nt.kind) {
21875       case OR:
21876         jj_consume_token(OR);
21877         jj_consume_token(REPLACE);
21878         break;
21879       default:
21880         jj_la1[292] = jj_gen;
21881         ;
21882       }
21883       switch (jj_nt.kind) {
21884       case FORCE:
21885       case NO:
21886         switch (jj_nt.kind) {
21887         case NO:
21888           jj_consume_token(NO);
21889           break;
21890         default:
21891           jj_la1[293] = jj_gen;
21892           ;
21893         }
21894         jj_consume_token(FORCE);
21895         break;
21896       default:
21897         jj_la1[294] = jj_gen;
21898         ;
21899       }
21900       jj_consume_token(VIEW);
21901       simpleNode = ObjectNameDeclaration();
21902       switch (jj_nt.kind) {
21903       case 5:
21904         jj_consume_token(5);
21905         ViewColumn();
21906         label_71:
21907         while (true) {
21908           switch (jj_nt.kind) {
21909           case 6:
21910             ;
21911             break;
21912           default:
21913             jj_la1[295] = jj_gen;
21914             break label_71;
21915           }
21916           jj_consume_token(6);
21917           ViewColumn();
21918         }
21919         jj_consume_token(7);
21920         break;
21921       default:
21922         jj_la1[296] = jj_gen;
21923         ;
21924       }
21925       jj_consume_token(AS);
21926       Statement();
21927       switch (jj_nt.kind) {
21928       case 4:
21929         jj_consume_token(4);
21930         break;
21931       case 1:
21932         jj_consume_token(1);
21933         break;
21934       default:
21935         jj_la1[297] = jj_gen;
21936         jj_consume_token(-1);
21937         throw new ParseException();
21938       }
21939     jjtree.closeNodeScope(jjtn000, true);
21940     jjtc000 = false;
21941     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
21942     } catch (Throwable jjte000) {
21943     if (jjtc000) {
21944       jjtree.clearNodeScope(jjtn000);
21945       jjtc000 = false;
21946     } else {
21947       jjtree.popNode();
21948     }
21949     if (jjte000 instanceof RuntimeException) {
21950       {if (true) throw (RuntimeException)jjte000;}
21951     }
21952     if (jjte000 instanceof ParseException) {
21953       {if (true) throw (ParseException)jjte000;}
21954     }
21955     {if (true) throw (Error)jjte000;}
21956     } finally {
21957     if (jjtc000) {
21958       jjtree.closeNodeScope(jjtn000, true);
21959     }
21960     }
21961     throw new Error("Missing return statement in function");
21962   }
21963 
21964   final public ASTSynonym Synonym() throws ParseException {
21965  /*@bgen(jjtree) Synonym */
21966  ASTSynonym jjtn000 = new ASTSynonym(this, JJTSYNONYM);
21967  boolean jjtc000 = true;
21968  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21969     try {
21970       jj_consume_token(CREATE);
21971       switch (jj_nt.kind) {
21972       case OR:
21973         jj_consume_token(OR);
21974         jj_consume_token(REPLACE);
21975         break;
21976       default:
21977         jj_la1[298] = jj_gen;
21978         ;
21979       }
21980       switch (jj_nt.kind) {
21981       case PUBLIC:
21982         jj_consume_token(PUBLIC);
21983         break;
21984       default:
21985         jj_la1[299] = jj_gen;
21986         ;
21987       }
21988       jj_consume_token(SYNONYM);
21989       simpleNode = ObjectNameDeclaration();
21990       jj_consume_token(FOR);
21991       ObjectNameDeclaration();
21992       switch (jj_nt.kind) {
21993       case 4:
21994         jj_consume_token(4);
21995         break;
21996       case 1:
21997         jj_consume_token(1);
21998         break;
21999       default:
22000         jj_la1[300] = jj_gen;
22001         jj_consume_token(-1);
22002         throw new ParseException();
22003       }
22004     jjtree.closeNodeScope(jjtn000, true);
22005     jjtc000 = false;
22006     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
22007     } catch (Throwable jjte000) {
22008     if (jjtc000) {
22009       jjtree.clearNodeScope(jjtn000);
22010       jjtc000 = false;
22011     } else {
22012       jjtree.popNode();
22013     }
22014     if (jjte000 instanceof RuntimeException) {
22015       {if (true) throw (RuntimeException)jjte000;}
22016     }
22017     if (jjte000 instanceof ParseException) {
22018       {if (true) throw (ParseException)jjte000;}
22019     }
22020     {if (true) throw (Error)jjte000;}
22021     } finally {
22022     if (jjtc000) {
22023       jjtree.closeNodeScope(jjtn000, true);
22024     }
22025     }
22026     throw new Error("Missing return statement in function");
22027   }
22028 
22029   final public ASTDirectory Directory() throws ParseException {
22030  /*@bgen(jjtree) Directory */
22031  ASTDirectory jjtn000 = new ASTDirectory(this, JJTDIRECTORY);
22032  boolean jjtc000 = true;
22033  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22034     try {
22035       jj_consume_token(CREATE);
22036       switch (jj_nt.kind) {
22037       case OR:
22038         jj_consume_token(OR);
22039         jj_consume_token(REPLACE);
22040         break;
22041       default:
22042         jj_la1[301] = jj_gen;
22043         ;
22044       }
22045       jj_consume_token(DIRECTORY);
22046       simpleNode = ObjectNameDeclaration();
22047       jj_consume_token(AS);
22048       StringLiteral();
22049       switch (jj_nt.kind) {
22050       case 4:
22051         jj_consume_token(4);
22052         break;
22053       case 1:
22054         jj_consume_token(1);
22055         break;
22056       default:
22057         jj_la1[302] = jj_gen;
22058         jj_consume_token(-1);
22059         throw new ParseException();
22060       }
22061     jjtree.closeNodeScope(jjtn000, true);
22062     jjtc000 = false;
22063     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
22064     } catch (Throwable jjte000) {
22065     if (jjtc000) {
22066       jjtree.clearNodeScope(jjtn000);
22067       jjtc000 = false;
22068     } else {
22069       jjtree.popNode();
22070     }
22071     if (jjte000 instanceof RuntimeException) {
22072       {if (true) throw (RuntimeException)jjte000;}
22073     }
22074     if (jjte000 instanceof ParseException) {
22075       {if (true) throw (ParseException)jjte000;}
22076     }
22077     {if (true) throw (Error)jjte000;}
22078     } finally {
22079     if (jjtc000) {
22080       jjtree.closeNodeScope(jjtn000, true);
22081     }
22082     }
22083     throw new Error("Missing return statement in function");
22084   }
22085 
22086   final public ASTDatabaseLink DatabaseLink() throws ParseException {
22087  /*@bgen(jjtree) DatabaseLink */
22088  ASTDatabaseLink jjtn000 = new ASTDatabaseLink(this, JJTDATABASELINK);
22089  boolean jjtc000 = true;
22090  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22091     try {
22092       jj_consume_token(CREATE);
22093       switch (jj_nt.kind) {
22094       case SHARED:
22095         jj_consume_token(SHARED);
22096         break;
22097       default:
22098         jj_la1[303] = jj_gen;
22099         ;
22100       }
22101       switch (jj_nt.kind) {
22102       case PUBLIC:
22103         jj_consume_token(PUBLIC);
22104         break;
22105       default:
22106         jj_la1[304] = jj_gen;
22107         ;
22108       }
22109       jj_consume_token(DATABASE);
22110       jj_consume_token(LINK);
22111       simpleNode = ObjectNameDeclaration();
22112       switch (jj_nt.kind) {
22113       case CONNECT:
22114         jj_consume_token(CONNECT);
22115         jj_consume_token(TO);
22116         switch (jj_nt.kind) {
22117         case CURRENT_USER:
22118           jj_consume_token(CURRENT_USER);
22119           break;
22120         case REPLACE:
22121         case DEFINER:
22122         case LANGUAGE:
22123         case ADD:
22124         case AGGREGATE:
22125         case ARRAY:
22126         case AT:
22127         case ATTRIBUTE:
22128         case AUTHID:
22129         case BODY:
22130         case BULK:
22131         case BYTE:
22132         case CASCADE:
22133         case CLOSE:
22134         case COALESCE:
22135         case COLLECT:
22136         case COLUMN:
22137         case COMMENT:
22138         case COMMIT:
22139         case CONSTRUCTOR:
22140         case CONTINUE:
22141         case CONVERT:
22142         case CURRENT:
22143         case CURSOR:
22144         case DATA:
22145         case DAY:
22146         case DISABLE:
22147         case EDITIONABLE:
22148         case ELEMENT:
22149         case ENABLE:
22150         case ESCAPE:
22151         case EXCEPT:
22152         case EXCEPTIONS:
22153         case EXIT:
22154         case EXTERNAL:
22155         case EXTENDS:
22156         case EXTRACT:
22157         case FALSE:
22158         case FINAL:
22159         case FORCE:
22160         case FUNCTION:
22161         case GLOBAL:
22162         case HASH:
22163         case HEAP:
22164         case HOUR:
22165         case IMMEDIATE:
22166         case INDICES:
22167         case INDEXTYPE:
22168         case INDICATOR:
22169         case INSTANTIABLE:
22170         case INTERVAL:
22171         case INVALIDATE:
22172         case ISOLATION:
22173         case JAVA:
22174         case LEVEL:
22175         case LIMIT:
22176         case LOOP:
22177         case MAP:
22178         case MAX:
22179         case MEMBER:
22180         case MERGE:
22181         case MIN:
22182         case MINUTE:
22183         case MLSLABEL:
22184         case MODIFY:
22185         case MOD:
22186         case MONTH:
22187         case NATURAL:
22188         case NEW:
22189         case NO:
22190         case NONEDITIONABLE:
22191         case NULLIF:
22192         case OBJECT:
22193         case OID:
22194         case OPAQUE:
22195         case OPEN:
22196         case OPERATOR:
22197         case ORGANIZATION:
22198         case OTHERS:
22199         case OVERRIDING:
22200         case PACKAGE:
22201         case PARTITION:
22202         case PRESERVE:
22203         case PRIVATE:
22204         case PROCEDURE:
22205         case RANGE:
22206         case RAW:
22207         case REAL:
22208         case RECORD:
22209         case REF:
22210         case RELEASE:
22211         case RELIES_ON:
22212         case RENAME:
22213         case RESULT:
22214         case RETURN:
22215         case RETURNING:
22216         case REVERSE:
22217         case ROLLBACK:
22218         case ROW:
22219         case ROWS:
22220         case ROWID:
22221         case ROWNUM:
22222         case SAVE:
22223         case SAVEPOINT:
22224         case SECOND:
22225         case SELF:
22226         case SET:
22227         case SPACE:
22228         case SQL:
22229         case SQLCODE:
22230         case SQLERRM:
22231         case STATIC:
22232         case SUBTYPE:
22233         case SUBSTITUTABLE:
22234         case SUCCESSFUL:
22235         case SYSDATE:
22236         case SYS_REFCURSOR:
22237         case TEMPORARY:
22238         case TIME:
22239         case TIMESTAMP:
22240         case TIMEZONE_REGION:
22241         case TIMEZONE_ABBR:
22242         case TIMEZONE_MINUTE:
22243         case TIMEZONE_HOUR:
22244         case TRANSACTION:
22245         case TRUE:
22246         case TYPE:
22247         case UNDER:
22248         case USING:
22249         case YES:
22250         case SHOW:
22251         case A:
22252         case DOUBLE:
22253         case DEC:
22254         case PRECISION:
22255         case INT:
22256         case NUMERIC:
22257         case NCHAR:
22258         case NVARCHAR2:
22259         case STRING:
22260         case UROWID:
22261         case VARRAY:
22262         case VARYING:
22263         case BFILE:
22264         case BLOB:
22265         case CLOB:
22266         case NCLOB:
22267         case YEAR:
22268         case LOCAL:
22269         case ZONE:
22270         case CHARACTER:
22271         case AFTER:
22272         case BEFORE:
22273         case OLD:
22274         case PARENT:
22275         case ANALYZE:
22276         case ASSOCIATE:
22277         case AUDIT:
22278         case COMPOUND:
22279         case DATABASE:
22280         case CALL:
22281         case DDL:
22282         case DISASSOCIATE:
22283         case EACH:
22284         case FOLLOWS:
22285         case LOGOFF:
22286         case LOGON:
22287         case NESTED:
22288         case NOAUDIT:
22289         case SCHEMA:
22290         case SERVERERROR:
22291         case SHUTDOWN:
22292         case STARTUP:
22293         case STATEMENT:
22294         case STATISTICS:
22295         case SUSPEND:
22296         case TRUNCATE:
22297         case WRAPPED:
22298         case LIBRARY:
22299         case NAME:
22300         case STRUCT:
22301         case CONTEXT:
22302         case PARAMETERS:
22303         case LENGTH:
22304         case TDO:
22305         case MAXLEN:
22306         case CHARSETID:
22307         case CHARSETFORM:
22308         case ACCEPT:
22309         case ACCESSIBLE:
22310         case COPY:
22311         case DEFINE:
22312         case DISCONNECT:
22313         case HOST:
22314         case PRINT:
22315         case QUIT:
22316         case REMARK:
22317         case UNDEFINE:
22318         case VARIABLE:
22319         case WHENEVER:
22320         case ATTACH:
22321         case CAST:
22322         case TREAT:
22323         case TRIM:
22324         case LEFT:
22325         case RIGHT:
22326         case BOTH:
22327         case EMPTY:
22328         case MULTISET:
22329         case SUBMULTISET:
22330         case LEADING:
22331         case TRAILING:
22332         case CHAR_CS:
22333         case NCHAR_CS:
22334         case DBTIMEZONE:
22335         case SESSIONTIMEZONE:
22336         case AUTHENTICATED:
22337         case LINK:
22338         case SHARED:
22339         case DIRECTORY:
22340         case USER:
22341         case IDENTIFIER:
22342         case QUOTED_LITERAL:
22343           UnqualifiedID();
22344           jj_consume_token(IDENTIFIED);
22345           jj_consume_token(BY);
22346           UnqualifiedID();
22347           jj_consume_token(AUTHENTICATED);
22348           jj_consume_token(BY);
22349           UnqualifiedID();
22350           jj_consume_token(IDENTIFIED);
22351           jj_consume_token(BY);
22352           UnqualifiedID();
22353           break;
22354         default:
22355           jj_la1[305] = jj_gen;
22356           jj_consume_token(-1);
22357           throw new ParseException();
22358         }
22359         break;
22360       case REPLACE:
22361       case DEFINER:
22362       case CURRENT_USER:
22363       case LANGUAGE:
22364       case ADD:
22365       case AGGREGATE:
22366       case ARRAY:
22367       case AT:
22368       case ATTRIBUTE:
22369       case AUTHID:
22370       case BODY:
22371       case BULK:
22372       case BYTE:
22373       case CASCADE:
22374       case CLOSE:
22375       case COALESCE:
22376       case COLLECT:
22377       case COLUMN:
22378       case COMMENT:
22379       case COMMIT:
22380       case CONSTRUCTOR:
22381       case CONTINUE:
22382       case CONVERT:
22383       case CURRENT:
22384       case CURSOR:
22385       case DATA:
22386       case DAY:
22387       case DISABLE:
22388       case EDITIONABLE:
22389       case ELEMENT:
22390       case ENABLE:
22391       case ESCAPE:
22392       case EXCEPT:
22393       case EXCEPTIONS:
22394       case EXIT:
22395       case EXTERNAL:
22396       case EXTENDS:
22397       case EXTRACT:
22398       case FALSE:
22399       case FINAL:
22400       case FORCE:
22401       case FUNCTION:
22402       case GLOBAL:
22403       case HASH:
22404       case HEAP:
22405       case HOUR:
22406       case IMMEDIATE:
22407       case INDICES:
22408       case INDEXTYPE:
22409       case INDICATOR:
22410       case INSTANTIABLE:
22411       case INTERVAL:
22412       case INVALIDATE:
22413       case ISOLATION:
22414       case JAVA:
22415       case LEVEL:
22416       case LIMIT:
22417       case LOOP:
22418       case MAP:
22419       case MAX:
22420       case MEMBER:
22421       case MERGE:
22422       case MIN:
22423       case MINUTE:
22424       case MLSLABEL:
22425       case MODIFY:
22426       case MOD:
22427       case MONTH:
22428       case NATURAL:
22429       case NEW:
22430       case NO:
22431       case NONEDITIONABLE:
22432       case NULLIF:
22433       case OBJECT:
22434       case OID:
22435       case OPAQUE:
22436       case OPEN:
22437       case OPERATOR:
22438       case ORGANIZATION:
22439       case OTHERS:
22440       case OVERRIDING:
22441       case PACKAGE:
22442       case PARTITION:
22443       case PRESERVE:
22444       case PRIVATE:
22445       case PROCEDURE:
22446       case RANGE:
22447       case RAW:
22448       case REAL:
22449       case RECORD:
22450       case REF:
22451       case RELEASE:
22452       case RELIES_ON:
22453       case RENAME:
22454       case RESULT:
22455       case RETURN:
22456       case RETURNING:
22457       case REVERSE:
22458       case ROLLBACK:
22459       case ROW:
22460       case ROWS:
22461       case ROWID:
22462       case ROWNUM:
22463       case SAVE:
22464       case SAVEPOINT:
22465       case SECOND:
22466       case SELF:
22467       case SET:
22468       case SPACE:
22469       case SQL:
22470       case SQLCODE:
22471       case SQLERRM:
22472       case STATIC:
22473       case SUBTYPE:
22474       case SUBSTITUTABLE:
22475       case SUCCESSFUL:
22476       case SYSDATE:
22477       case SYS_REFCURSOR:
22478       case TEMPORARY:
22479       case TIME:
22480       case TIMESTAMP:
22481       case TIMEZONE_REGION:
22482       case TIMEZONE_ABBR:
22483       case TIMEZONE_MINUTE:
22484       case TIMEZONE_HOUR:
22485       case TRANSACTION:
22486       case TRUE:
22487       case TYPE:
22488       case UNDER:
22489       case USING:
22490       case YES:
22491       case SHOW:
22492       case A:
22493       case DOUBLE:
22494       case DEC:
22495       case PRECISION:
22496       case INT:
22497       case NUMERIC:
22498       case NCHAR:
22499       case NVARCHAR2:
22500       case STRING:
22501       case UROWID:
22502       case VARRAY:
22503       case VARYING:
22504       case BFILE:
22505       case BLOB:
22506       case CLOB:
22507       case NCLOB:
22508       case YEAR:
22509       case LOCAL:
22510       case ZONE:
22511       case CHARACTER:
22512       case AFTER:
22513       case BEFORE:
22514       case OLD:
22515       case PARENT:
22516       case ANALYZE:
22517       case ASSOCIATE:
22518       case AUDIT:
22519       case COMPOUND:
22520       case DATABASE:
22521       case CALL:
22522       case DDL:
22523       case DISASSOCIATE:
22524       case EACH:
22525       case FOLLOWS:
22526       case LOGOFF:
22527       case LOGON:
22528       case NESTED:
22529       case NOAUDIT:
22530       case SCHEMA:
22531       case SERVERERROR:
22532       case SHUTDOWN:
22533       case STARTUP:
22534       case STATEMENT:
22535       case STATISTICS:
22536       case SUSPEND:
22537       case TRUNCATE:
22538       case WRAPPED:
22539       case LIBRARY:
22540       case NAME:
22541       case STRUCT:
22542       case CONTEXT:
22543       case PARAMETERS:
22544       case LENGTH:
22545       case TDO:
22546       case MAXLEN:
22547       case CHARSETID:
22548       case CHARSETFORM:
22549       case ACCEPT:
22550       case ACCESSIBLE:
22551       case COPY:
22552       case DEFINE:
22553       case DISCONNECT:
22554       case HOST:
22555       case PRINT:
22556       case QUIT:
22557       case REMARK:
22558       case UNDEFINE:
22559       case VARIABLE:
22560       case WHENEVER:
22561       case ATTACH:
22562       case CAST:
22563       case TREAT:
22564       case TRIM:
22565       case LEFT:
22566       case RIGHT:
22567       case BOTH:
22568       case EMPTY:
22569       case MULTISET:
22570       case SUBMULTISET:
22571       case LEADING:
22572       case TRAILING:
22573       case CHAR_CS:
22574       case NCHAR_CS:
22575       case DBTIMEZONE:
22576       case SESSIONTIMEZONE:
22577       case AUTHENTICATED:
22578       case LINK:
22579       case SHARED:
22580       case DIRECTORY:
22581       case USER:
22582       case IDENTIFIER:
22583       case QUOTED_LITERAL:
22584         UnqualifiedID();
22585         jj_consume_token(IDENTIFIED);
22586         jj_consume_token(BY);
22587         UnqualifiedID();
22588         break;
22589       default:
22590         jj_la1[306] = jj_gen;
22591         jj_consume_token(-1);
22592         throw new ParseException();
22593       }
22594       switch (jj_nt.kind) {
22595       case USING:
22596         jj_consume_token(USING);
22597         StringLiteral();
22598         break;
22599       default:
22600         jj_la1[307] = jj_gen;
22601         ;
22602       }
22603       switch (jj_nt.kind) {
22604       case 4:
22605         jj_consume_token(4);
22606         break;
22607       case 1:
22608         jj_consume_token(1);
22609         break;
22610       default:
22611         jj_la1[308] = jj_gen;
22612         jj_consume_token(-1);
22613         throw new ParseException();
22614       }
22615     jjtree.closeNodeScope(jjtn000, true);
22616     jjtc000 = false;
22617     jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
22618     } catch (Throwable jjte000) {
22619     if (jjtc000) {
22620       jjtree.clearNodeScope(jjtn000);
22621       jjtc000 = false;
22622     } else {
22623       jjtree.popNode();
22624     }
22625     if (jjte000 instanceof RuntimeException) {
22626       {if (true) throw (RuntimeException)jjte000;}
22627     }
22628     if (jjte000 instanceof ParseException) {
22629       {if (true) throw (ParseException)jjte000;}
22630     }
22631     {if (true) throw (Error)jjte000;}
22632     } finally {
22633     if (jjtc000) {
22634       jjtree.closeNodeScope(jjtn000, true);
22635     }
22636     }
22637     throw new Error("Missing return statement in function");
22638   }
22639 
22640   final public ASTViewColumn ViewColumn() throws ParseException {
22641  /*@bgen(jjtree) ViewColumn */
22642   ASTViewColumn jjtn000 = new ASTViewColumn(this, JJTVIEWCOLUMN);
22643   boolean jjtc000 = true;
22644   jjtree.openNodeScope(jjtn000);
22645     try {
22646       ID();
22647         jjtree.closeNodeScope(jjtn000, true);
22648         jjtc000 = false;
22649         {if (true) return jjtn000 ;}
22650     } catch (Throwable jjte000) {
22651     if (jjtc000) {
22652       jjtree.clearNodeScope(jjtn000);
22653       jjtc000 = false;
22654     } else {
22655       jjtree.popNode();
22656     }
22657     if (jjte000 instanceof RuntimeException) {
22658       {if (true) throw (RuntimeException)jjte000;}
22659     }
22660     if (jjte000 instanceof ParseException) {
22661       {if (true) throw (ParseException)jjte000;}
22662     }
22663     {if (true) throw (Error)jjte000;}
22664     } finally {
22665     if (jjtc000) {
22666       jjtree.closeNodeScope(jjtn000, true);
22667     }
22668     }
22669     throw new Error("Missing return statement in function");
22670   }
22671 
22672   final public ASTComment Comment() throws ParseException {
22673  /*@bgen(jjtree) Comment */
22674   ASTComment jjtn000 = new ASTComment(this, JJTCOMMENT);
22675   boolean jjtc000 = true;
22676   jjtree.openNodeScope(jjtn000);
22677     try {
22678       jj_consume_token(COMMENT);
22679       jj_consume_token(ON);
22680       switch (jj_nt.kind) {
22681       case INDEXTYPE:
22682       case OPERATOR:
22683       case TABLE:
22684         switch (jj_nt.kind) {
22685         case TABLE:
22686           jj_consume_token(TABLE);
22687           break;
22688         case OPERATOR:
22689           jj_consume_token(OPERATOR);
22690           break;
22691         case INDEXTYPE:
22692           jj_consume_token(INDEXTYPE);
22693           break;
22694         default:
22695           jj_la1[309] = jj_gen;
22696           jj_consume_token(-1);
22697           throw new ParseException();
22698         }
22699         if (jj_2_59(2)) {
22700           ID();
22701           jj_consume_token(3);
22702         } else {
22703           ;
22704         }
22705         ID();
22706         break;
22707       case COLUMN:
22708         jj_consume_token(COLUMN);
22709         if (jj_2_60(2147483647)) {
22710           ID();
22711           jj_consume_token(3);
22712         } else {
22713           ;
22714         }
22715         ID();
22716         jj_consume_token(3);
22717         ID();
22718         break;
22719       default:
22720         jj_la1[310] = jj_gen;
22721         jj_consume_token(-1);
22722         throw new ParseException();
22723       }
22724       jj_consume_token(IS);
22725       jj_consume_token(STRING_LITERAL);
22726       switch (jj_nt.kind) {
22727       case 4:
22728         jj_consume_token(4);
22729         break;
22730       default:
22731         jj_la1[311] = jj_gen;
22732         ;
22733       }
22734         jjtree.closeNodeScope(jjtn000, true);
22735         jjtc000 = false;
22736         {if (true) return jjtn000 ;}
22737     } catch (Throwable jjte000) {
22738     if (jjtc000) {
22739       jjtree.clearNodeScope(jjtn000);
22740       jjtc000 = false;
22741     } else {
22742       jjtree.popNode();
22743     }
22744     if (jjte000 instanceof RuntimeException) {
22745       {if (true) throw (RuntimeException)jjte000;}
22746     }
22747     if (jjte000 instanceof ParseException) {
22748       {if (true) throw (ParseException)jjte000;}
22749     }
22750     {if (true) throw (Error)jjte000;}
22751     } finally {
22752     if (jjtc000) {
22753       jjtree.closeNodeScope(jjtn000, true);
22754     }
22755     }
22756     throw new Error("Missing return statement in function");
22757   }
22758 
22759 // SRT * /
22760   final public ASTTypeMethod TypeMethod() throws ParseException {
22761  /*@bgen(jjtree) TypeMethod */
22762   ASTTypeMethod jjtn000 = new ASTTypeMethod(this, JJTTYPEMETHOD);
22763   boolean jjtc000 = true;
22764   jjtree.openNodeScope(jjtn000);
22765     try {
22766         getToken(1);
22767         //System.err.println("typeMethod: Result of getToken(1) is \"" + startToken.toString() + "\"" );
22768 
22769       label_72:
22770       while (true) {
22771         switch (jj_nt.kind) {
22772         case FINAL:
22773         case INSTANTIABLE:
22774         case NOT:
22775         case OVERRIDING:
22776           ;
22777           break;
22778         default:
22779           jj_la1[312] = jj_gen;
22780           break label_72;
22781         }
22782         switch (jj_nt.kind) {
22783         case NOT:
22784           jj_consume_token(NOT);
22785           break;
22786         default:
22787           jj_la1[313] = jj_gen;
22788           ;
22789         }
22790         switch (jj_nt.kind) {
22791         case OVERRIDING:
22792           jj_consume_token(OVERRIDING);
22793           break;
22794         case INSTANTIABLE:
22795           jj_consume_token(INSTANTIABLE);
22796           break;
22797         case FINAL:
22798           jj_consume_token(FINAL);
22799           break;
22800         default:
22801           jj_la1[314] = jj_gen;
22802           jj_consume_token(-1);
22803           throw new ParseException();
22804         }
22805       }
22806       switch (jj_nt.kind) {
22807       case MAP:
22808       case ORDER:
22809         switch (jj_nt.kind) {
22810         case MAP:
22811           jj_consume_token(MAP);
22812           break;
22813         case ORDER:
22814           jj_consume_token(ORDER);
22815           break;
22816         default:
22817           jj_la1[315] = jj_gen;
22818           jj_consume_token(-1);
22819           throw new ParseException();
22820         }
22821         break;
22822       default:
22823         jj_la1[316] = jj_gen;
22824         ;
22825       }
22826       switch (jj_nt.kind) {
22827       case CONSTRUCTOR:
22828         jj_consume_token(CONSTRUCTOR);
22829         break;
22830       case MEMBER:
22831         jj_consume_token(MEMBER);
22832         break;
22833       case STATIC:
22834         jj_consume_token(STATIC);
22835         break;
22836       default:
22837         jj_la1[317] = jj_gen;
22838         jj_consume_token(-1);
22839         throw new ParseException();
22840       }
22841       MethodDeclarator();
22842       switch (jj_nt.kind) {
22843       case DETERMINISTIC:
22844         jj_consume_token(DETERMINISTIC);
22845         break;
22846       default:
22847         jj_la1[318] = jj_gen;
22848         ;
22849       }
22850       switch (jj_nt.kind) {
22851       case PARALLEL_ENABLE:
22852         jj_consume_token(PARALLEL_ENABLE);
22853         break;
22854       default:
22855         jj_la1[319] = jj_gen;
22856         ;
22857       }
22858       switch (jj_nt.kind) {
22859       case PIPELINED:
22860         jj_consume_token(PIPELINED);
22861         break;
22862       default:
22863         jj_la1[320] = jj_gen;
22864         ;
22865       }
22866       switch (jj_nt.kind) {
22867       case RESULT_CACHE:
22868         jj_consume_token(RESULT_CACHE);
22869         break;
22870       default:
22871         jj_la1[321] = jj_gen;
22872         ;
22873       }
22874       switch (jj_nt.kind) {
22875       case AS:
22876       case IS:
22877         switch (jj_nt.kind) {
22878         case IS:
22879           jj_consume_token(IS);
22880           break;
22881         case AS:
22882           jj_consume_token(AS);
22883           break;
22884         default:
22885           jj_la1[322] = jj_gen;
22886           jj_consume_token(-1);
22887           throw new ParseException();
22888         }
22889         switch (jj_nt.kind) {
22890         case LANGUAGE:
22891         case EXTERNAL:
22892           CallSpecTail();
22893           switch (jj_nt.kind) {
22894           case 4:
22895             jj_consume_token(4);
22896             break;
22897           default:
22898             jj_la1[323] = jj_gen;
22899             ;
22900           }
22901           break;
22902         case REPLACE:
22903         case DEFINER:
22904         case CURRENT_USER:
22905         case SERIALLY_REUSABLE:
22906         case RESTRICT_REFERENCES:
22907         case EXCEPTION_INIT:
22908         case AUTONOMOUS_TRANSACTION:
22909         case ADD:
22910         case AGGREGATE:
22911         case ALL:
22912         case ALTER:
22913         case AND:
22914         case ANY:
22915         case ARRAY:
22916         case AS:
22917         case ASC:
22918         case AT:
22919         case ATTRIBUTE:
22920         case AUTHID:
22921         case AVG:
22922         case BEGIN:
22923         case BETWEEN:
22924         case BINARY_INTEGER:
22925         case BODY:
22926         case BOOLEAN:
22927         case BULK:
22928         case BY:
22929         case BYTE:
22930         case CASCADE:
22931         case CASE:
22932         case CHAR:
22933         case CHAR_BASE:
22934         case CHECK:
22935         case CLOSE:
22936         case CLUSTER:
22937         case COALESCE:
22938         case COLLECT:
22939         case COLUMN:
22940         case COMMENT:
22941         case COMMIT:
22942         case COMPRESS:
22943         case CONNECT:
22944         case CONSTANT:
22945         case CONSTRUCTOR:
22946         case CONTINUE:
22947         case CONVERT:
22948         case CREATE:
22949         case CURRENT:
22950         case CURRVAL:
22951         case CURSOR:
22952         case DATA:
22953         case DATE:
22954         case DAY:
22955         case DECLARE:
22956         case DECIMAL:
22957         case _DEFAULT:
22958         case DELETE:
22959         case DESC:
22960         case DISABLE:
22961         case DISTINCT:
22962         case DO:
22963         case DROP:
22964         case EDITIONABLE:
22965         case ELEMENT:
22966         case ELSE:
22967         case ELSIF:
22968         case ENABLE:
22969         case ESCAPE:
22970         case EXCEPT:
22971         case EXCEPTION:
22972         case EXCEPTIONS:
22973         case EXCLUSIVE:
22974         case EXECUTE:
22975         case EXISTS:
22976         case EXIT:
22977         case EXTENDS:
22978         case EXTRACT:
22979         case FALSE:
22980         case FETCH:
22981         case FINAL:
22982         case FLOAT:
22983         case FOR:
22984         case FORALL:
22985         case FORCE:
22986         case FROM:
22987         case FUNCTION:
22988         case GLOBAL:
22989         case GOTO:
22990         case GROUP:
22991         case HASH:
22992         case HAVING:
22993         case HEAP:
22994         case HOUR:
22995         case IF:
22996         case IMMEDIATE:
22997         case IN:
22998         case INDEX:
22999         case INDICES:
23000         case INDEXTYPE:
23001         case INDICATOR:
23002         case INSERT:
23003         case INSTANTIABLE:
23004         case INTEGER:
23005         case INTERFACE:
23006         case INTERSECT:
23007         case INTERVAL:
23008         case INTO:
23009         case INVALIDATE:
23010         case IS:
23011         case ISOLATION:
23012         case JAVA:
23013         case LEVEL:
23014         case LIKE:
23015         case LIMIT:
23016         case LIMITED:
23017         case LOCK:
23018         case LONG:
23019         case LOOP:
23020         case MAP:
23021         case MAX:
23022         case MEMBER:
23023         case MERGE:
23024         case MIN:
23025         case MINUS:
23026         case MINUTE:
23027         case MLSLABEL:
23028         case MODIFY:
23029         case MOD:
23030         case MODE:
23031         case MONTH:
23032         case NATURAL:
23033         case NATURALN:
23034         case NEW:
23035         case NEXTVAL:
23036         case NO:
23037         case NOCOPY:
23038         case NONEDITIONABLE:
23039         case NOT:
23040         case NOWAIT:
23041         case NULL:
23042         case NULLIF:
23043         case NUMBER:
23044         case BFILE_BASE:
23045         case BLOB_BASE:
23046         case CLOB_BASE:
23047         case DATE_BASE:
23048         case NUMBER_BASE:
23049         case OBJECT:
23050         case OCIROWID:
23051         case OF:
23052         case OID:
23053         case ON:
23054         case OPAQUE:
23055         case OPEN:
23056         case OPERATOR:
23057         case OPTION:
23058         case OR:
23059         case ORDER:
23060         case ORGANIZATION:
23061         case OTHERS:
23062         case OUT:
23063         case OVERRIDING:
23064         case PACKAGE:
23065         case PARTITION:
23066         case PCTFREE:
23067         case PLS_INTEGER:
23068         case POSITIVE:
23069         case POSITIVEN:
23070         case PRAGMA:
23071         case PRESERVE:
23072         case PRIOR:
23073         case PROMPT:
23074         case PRIVATE:
23075         case PROCEDURE:
23076         case PUBLIC:
23077         case RAISE:
23078         case RANGE:
23079         case RAW:
23080         case REAL:
23081         case RECORD:
23082         case REF:
23083         case RELEASE:
23084         case RELIES_ON:
23085         case RENAME:
23086         case RESULT:
23087         case RETURN:
23088         case RETURNING:
23089         case REVERSE:
23090         case ROLLBACK:
23091         case ROW:
23092         case ROWS:
23093         case ROWID:
23094         case ROWNUM:
23095         case ROWTYPE:
23096         case SAVE:
23097         case SAVEPOINT:
23098         case SECOND:
23099         case SELECT:
23100         case SELF:
23101         case SEPARATE:
23102         case SET:
23103         case SHARE:
23104         case SMALLINT:
23105         case SPACE:
23106         case SQL:
23107         case SQLCODE:
23108         case SQLERRM:
23109         case START:
23110         case STATIC:
23111         case STDDEV:
23112         case SUBTYPE:
23113         case SUBSTITUTABLE:
23114         case SUCCESSFUL:
23115         case SUM:
23116         case SYNONYM:
23117         case SYSDATE:
23118         case SYS_REFCURSOR:
23119         case TABLE:
23120         case TEMPORARY:
23121         case THEN:
23122         case TIME:
23123         case TIMESTAMP:
23124         case TIMEZONE_REGION:
23125         case TIMEZONE_ABBR:
23126         case TIMEZONE_MINUTE:
23127         case TIMEZONE_HOUR:
23128         case TO:
23129         case TRANSACTION:
23130         case TRIGGER:
23131         case TRUE:
23132         case TYPE:
23133         case UI:
23134         case UNDER:
23135         case USING:
23136         case WHILE:
23137         case YES:
23138         case SHOW:
23139         case A:
23140         case UPDATE:
23141         case VARCHAR:
23142         case VARCHAR2:
23143         case DOUBLE:
23144         case DEC:
23145         case PRECISION:
23146         case INT:
23147         case NUMERIC:
23148         case SIGNTYPE:
23149         case NCHAR:
23150         case NVARCHAR2:
23151         case STRING:
23152         case UROWID:
23153         case VARRAY:
23154         case VARYING:
23155         case BFILE:
23156         case BLOB:
23157         case CLOB:
23158         case NCLOB:
23159         case YEAR:
23160         case LOCAL:
23161         case WITH:
23162         case ZONE:
23163         case CHARACTER:
23164         case AFTER:
23165         case BEFORE:
23166         case OLD:
23167         case PARENT:
23168         case CC_IF:
23169         case ANALYZE:
23170         case ASSOCIATE:
23171         case AUDIT:
23172         case COMPOUND:
23173         case DATABASE:
23174         case CALL:
23175         case DDL:
23176         case DISASSOCIATE:
23177         case EACH:
23178         case FOLLOWS:
23179         case LOGOFF:
23180         case LOGON:
23181         case NESTED:
23182         case NOAUDIT:
23183         case SCHEMA:
23184         case SERVERERROR:
23185         case SHUTDOWN:
23186         case STARTUP:
23187         case STATEMENT:
23188         case STATISTICS:
23189         case SUSPEND:
23190         case TRUNCATE:
23191         case WRAPPED:
23192         case LIBRARY:
23193         case NAME:
23194         case STRUCT:
23195         case CONTEXT:
23196         case PARAMETERS:
23197         case LENGTH:
23198         case TDO:
23199         case MAXLEN:
23200         case CHARSETID:
23201         case CHARSETFORM:
23202         case ACCEPT:
23203         case ACCESSIBLE:
23204         case COPY:
23205         case DEFINE:
23206         case DISCONNECT:
23207         case HOST:
23208         case PRINT:
23209         case QUIT:
23210         case REMARK:
23211         case UNDEFINE:
23212         case VARIABLE:
23213         case WHENEVER:
23214         case ATTACH:
23215         case CAST:
23216         case TREAT:
23217         case TRIM:
23218         case LEFT:
23219         case RIGHT:
23220         case BOTH:
23221         case EMPTY:
23222         case MULTISET:
23223         case SUBMULTISET:
23224         case LEADING:
23225         case TRAILING:
23226         case CHAR_CS:
23227         case NCHAR_CS:
23228         case DBTIMEZONE:
23229         case SESSIONTIMEZONE:
23230         case AUTHENTICATED:
23231         case LINK:
23232         case SHARED:
23233         case DIRECTORY:
23234         case USER:
23235         case IDENTIFIER:
23236         case QUOTED_LITERAL:
23237         case SQLDATA_CLASS:
23238         case CUSTOMDATUM_CLASS:
23239         case ORADATA_CLASS:
23240         case JAVA_INTERFACE_CLASS:
23241           DeclarativeSection();
23242           jj_consume_token(BEGIN);
23243           label_73:
23244           while (true) {
23245             switch (jj_nt.kind) {
23246             case 5:
23247             case 16:
23248             case 17:
23249             case 21:
23250             case REPLACE:
23251             case DEFINER:
23252             case CURRENT_USER:
23253             case LANGUAGE:
23254             case ADD:
23255             case AGGREGATE:
23256             case ARRAY:
23257             case AT:
23258             case ATTRIBUTE:
23259             case AUTHID:
23260             case BEGIN:
23261             case BODY:
23262             case BULK:
23263             case BYTE:
23264             case CASCADE:
23265             case CASE:
23266             case CLOSE:
23267             case COALESCE:
23268             case COLLECT:
23269             case COLUMN:
23270             case COMMENT:
23271             case COMMIT:
23272             case CONSTRUCTOR:
23273             case CONTINUE:
23274             case CONVERT:
23275             case CURRENT:
23276             case CURSOR:
23277             case DATA:
23278             case DATE:
23279             case DAY:
23280             case DECLARE:
23281             case DELETE:
23282             case DISABLE:
23283             case EDITIONABLE:
23284             case ELEMENT:
23285             case ENABLE:
23286             case ESCAPE:
23287             case EXCEPT:
23288             case EXCEPTIONS:
23289             case EXECUTE:
23290             case EXIT:
23291             case EXTERNAL:
23292             case EXTENDS:
23293             case EXTRACT:
23294             case FALSE:
23295             case FETCH:
23296             case FINAL:
23297             case FOR:
23298             case FORALL:
23299             case FORCE:
23300             case FUNCTION:
23301             case GLOBAL:
23302             case GOTO:
23303             case HASH:
23304             case HEAP:
23305             case HOUR:
23306             case IF:
23307             case IMMEDIATE:
23308             case INDICES:
23309             case INDEXTYPE:
23310             case INDICATOR:
23311             case INSERT:
23312             case INSTANTIABLE:
23313             case INTERVAL:
23314             case INVALIDATE:
23315             case ISOLATION:
23316             case JAVA:
23317             case LEVEL:
23318             case LIMIT:
23319             case LOCK:
23320             case LOOP:
23321             case MAP:
23322             case MAX:
23323             case MEMBER:
23324             case MERGE:
23325             case MIN:
23326             case MINUTE:
23327             case MLSLABEL:
23328             case MODIFY:
23329             case MOD:
23330             case MONTH:
23331             case NATURAL:
23332             case NEW:
23333             case NEW_DOT:
23334             case NO:
23335             case NONEDITIONABLE:
23336             case NOT:
23337             case NULL:
23338             case NULLIF:
23339             case OBJECT:
23340             case OID:
23341             case OPAQUE:
23342             case OPEN:
23343             case OPERATOR:
23344             case ORGANIZATION:
23345             case OTHERS:
23346             case OVERRIDING:
23347             case PACKAGE:
23348             case PARTITION:
23349             case PIPE:
23350             case PRESERVE:
23351             case PRIVATE:
23352             case PROCEDURE:
23353             case RAISE:
23354             case RANGE:
23355             case RAW:
23356             case REAL:
23357             case RECORD:
23358             case REF:
23359             case RELEASE:
23360             case RELIES_ON:
23361             case RENAME:
23362             case RESULT:
23363             case RETURN:
23364             case RETURNING:
23365             case REVERSE:
23366             case ROLLBACK:
23367             case ROW:
23368             case ROWS:
23369             case ROWID:
23370             case ROWNUM:
23371             case SAVE:
23372             case SAVEPOINT:
23373             case SECOND:
23374             case SELECT:
23375             case SELF:
23376             case SET:
23377             case SPACE:
23378             case SQL:
23379             case SQLCODE:
23380             case SQLERRM:
23381             case STATIC:
23382             case SUBTYPE:
23383             case SUBSTITUTABLE:
23384             case SUCCESSFUL:
23385             case SYSDATE:
23386             case SYS_REFCURSOR:
23387             case TEMPORARY:
23388             case TIME:
23389             case TIMESTAMP:
23390             case TIMEZONE_REGION:
23391             case TIMEZONE_ABBR:
23392             case TIMEZONE_MINUTE:
23393             case TIMEZONE_HOUR:
23394             case TRANSACTION:
23395             case TRUE:
23396             case TYPE:
23397             case UNDER:
23398             case USING:
23399             case WHILE:
23400             case YES:
23401             case SHOW:
23402             case A:
23403             case UPDATE:
23404             case DOUBLE:
23405             case DEC:
23406             case PRECISION:
23407             case INT:
23408             case NUMERIC:
23409             case NCHAR:
23410             case NVARCHAR2:
23411             case STRING:
23412             case UROWID:
23413             case VARRAY:
23414             case VARYING:
23415             case BFILE:
23416             case BLOB:
23417             case CLOB:
23418             case NCLOB:
23419             case YEAR:
23420             case LOCAL:
23421             case WITH:
23422             case ZONE:
23423             case CHARACTER:
23424             case AFTER:
23425             case BEFORE:
23426             case OLD:
23427             case PARENT:
23428             case CC_IF:
23429             case CC_ERROR:
23430             case ANALYZE:
23431             case ASSOCIATE:
23432             case AUDIT:
23433             case COMPOUND:
23434             case DATABASE:
23435             case CALL:
23436             case DDL:
23437             case DISASSOCIATE:
23438             case EACH:
23439             case FOLLOWS:
23440             case LOGOFF:
23441             case LOGON:
23442             case NESTED:
23443             case NOAUDIT:
23444             case SCHEMA:
23445             case SERVERERROR:
23446             case SHUTDOWN:
23447             case STARTUP:
23448             case STATEMENT:
23449             case STATISTICS:
23450             case SUSPEND:
23451             case TRUNCATE:
23452             case WRAPPED:
23453             case LIBRARY:
23454             case NAME:
23455             case STRUCT:
23456             case CONTEXT:
23457             case PARAMETERS:
23458             case LENGTH:
23459             case TDO:
23460             case MAXLEN:
23461             case CHARSETID:
23462             case CHARSETFORM:
23463             case ACCEPT:
23464             case ACCESSIBLE:
23465             case COPY:
23466             case DEFINE:
23467             case DISCONNECT:
23468             case HOST:
23469             case PRINT:
23470             case QUIT:
23471             case REMARK:
23472             case UNDEFINE:
23473             case VARIABLE:
23474             case WHENEVER:
23475             case ATTACH:
23476             case CAST:
23477             case TREAT:
23478             case TRIM:
23479             case LEFT:
23480             case RIGHT:
23481             case BOTH:
23482             case EMPTY:
23483             case MULTISET:
23484             case SUBMULTISET:
23485             case LEADING:
23486             case TRAILING:
23487             case CHAR_CS:
23488             case NCHAR_CS:
23489             case DBTIMEZONE:
23490             case SESSIONTIMEZONE:
23491             case AUTHENTICATED:
23492             case LINK:
23493             case SHARED:
23494             case DIRECTORY:
23495             case USER:
23496             case IDENTIFIER:
23497             case UNSIGNED_NUMERIC_LITERAL:
23498             case CHARACTER_LITERAL:
23499             case STRING_LITERAL:
23500             case QUOTED_LITERAL:
23501               ;
23502               break;
23503             default:
23504               jj_la1[324] = jj_gen;
23505               break label_73;
23506             }
23507             Statement();
23508           }
23509           switch (jj_nt.kind) {
23510           case EXCEPTION:
23511             ExceptionHandler();
23512             break;
23513           default:
23514             jj_la1[325] = jj_gen;
23515             ;
23516           }
23517           jj_consume_token(END);
23518           switch (jj_nt.kind) {
23519           case REPLACE:
23520           case DEFINER:
23521           case CURRENT_USER:
23522           case SERIALLY_REUSABLE:
23523           case RESTRICT_REFERENCES:
23524           case EXCEPTION_INIT:
23525           case AUTONOMOUS_TRANSACTION:
23526           case LANGUAGE:
23527           case ADD:
23528           case AGGREGATE:
23529           case ALL:
23530           case ALTER:
23531           case AND:
23532           case ANY:
23533           case ARRAY:
23534           case AS:
23535           case ASC:
23536           case AT:
23537           case ATTRIBUTE:
23538           case AUTHID:
23539           case AVG:
23540           case BETWEEN:
23541           case BINARY_INTEGER:
23542           case BODY:
23543           case BOOLEAN:
23544           case BULK:
23545           case BY:
23546           case BYTE:
23547           case CASCADE:
23548           case CASE:
23549           case CHAR:
23550           case CHAR_BASE:
23551           case CHECK:
23552           case CLOSE:
23553           case CLUSTER:
23554           case COALESCE:
23555           case COLLECT:
23556           case COLUMN:
23557           case COMMENT:
23558           case COMMIT:
23559           case COMPRESS:
23560           case CONNECT:
23561           case CONSTANT:
23562           case CONSTRUCTOR:
23563           case CONTINUE:
23564           case CONVERT:
23565           case CREATE:
23566           case CURRENT:
23567           case CURRVAL:
23568           case CURSOR:
23569           case DATA:
23570           case DATE:
23571           case DAY:
23572           case DECLARE:
23573           case DECIMAL:
23574           case _DEFAULT:
23575           case DELETE:
23576           case DESC:
23577           case DISABLE:
23578           case DISTINCT:
23579           case DO:
23580           case DROP:
23581           case EDITIONABLE:
23582           case ELEMENT:
23583           case ELSE:
23584           case ELSIF:
23585           case ENABLE:
23586           case ESCAPE:
23587           case EXCEPT:
23588           case EXCEPTION:
23589           case EXCEPTIONS:
23590           case EXCLUSIVE:
23591           case EXECUTE:
23592           case EXISTS:
23593           case EXIT:
23594           case EXTERNAL:
23595           case EXTENDS:
23596           case EXTRACT:
23597           case FALSE:
23598           case FETCH:
23599           case FINAL:
23600           case FLOAT:
23601           case FOR:
23602           case FORALL:
23603           case FORCE:
23604           case FROM:
23605           case FUNCTION:
23606           case GLOBAL:
23607           case GOTO:
23608           case GROUP:
23609           case HASH:
23610           case HAVING:
23611           case HEAP:
23612           case HOUR:
23613           case IF:
23614           case IMMEDIATE:
23615           case IN:
23616           case INDEX:
23617           case INDICES:
23618           case INDEXTYPE:
23619           case INDICATOR:
23620           case INSERT:
23621           case INSTANTIABLE:
23622           case INTEGER:
23623           case INTERFACE:
23624           case INTERSECT:
23625           case INTERVAL:
23626           case INTO:
23627           case INVALIDATE:
23628           case IS:
23629           case ISOLATION:
23630           case JAVA:
23631           case LEVEL:
23632           case LIKE:
23633           case LIMIT:
23634           case LIMITED:
23635           case LOCK:
23636           case LONG:
23637           case LOOP:
23638           case MAP:
23639           case MAX:
23640           case MEMBER:
23641           case MERGE:
23642           case MIN:
23643           case MINUS:
23644           case MINUTE:
23645           case MLSLABEL:
23646           case MODIFY:
23647           case MOD:
23648           case MODE:
23649           case MONTH:
23650           case NATURAL:
23651           case NATURALN:
23652           case NEW:
23653           case NEXTVAL:
23654           case NO:
23655           case NOCOPY:
23656           case NONEDITIONABLE:
23657           case NOT:
23658           case NOWAIT:
23659           case NULL:
23660           case NULLIF:
23661           case NUMBER:
23662           case BFILE_BASE:
23663           case BLOB_BASE:
23664           case CLOB_BASE:
23665           case DATE_BASE:
23666           case NUMBER_BASE:
23667           case OBJECT:
23668           case OCIROWID:
23669           case OF:
23670           case OID:
23671           case ON:
23672           case OPAQUE:
23673           case OPEN:
23674           case OPERATOR:
23675           case OPTION:
23676           case OR:
23677           case ORDER:
23678           case ORGANIZATION:
23679           case OTHERS:
23680           case OUT:
23681           case OVERRIDING:
23682           case PACKAGE:
23683           case PARTITION:
23684           case PCTFREE:
23685           case PLS_INTEGER:
23686           case POSITIVE:
23687           case POSITIVEN:
23688           case PRESERVE:
23689           case PRIOR:
23690           case PROMPT:
23691           case PRIVATE:
23692           case PROCEDURE:
23693           case PUBLIC:
23694           case RAISE:
23695           case RANGE:
23696           case RAW:
23697           case REAL:
23698           case RECORD:
23699           case REF:
23700           case RELEASE:
23701           case RELIES_ON:
23702           case RENAME:
23703           case RESULT:
23704           case RETURN:
23705           case RETURNING:
23706           case REVERSE:
23707           case ROLLBACK:
23708           case ROW:
23709           case ROWS:
23710           case ROWID:
23711           case ROWNUM:
23712           case ROWTYPE:
23713           case SAVE:
23714           case SAVEPOINT:
23715           case SECOND:
23716           case SELECT:
23717           case SELF:
23718           case SEPARATE:
23719           case SET:
23720           case SHARE:
23721           case SMALLINT:
23722           case SPACE:
23723           case SQL:
23724           case SQLCODE:
23725           case SQLERRM:
23726           case START:
23727           case STATIC:
23728           case STDDEV:
23729           case SUBTYPE:
23730           case SUBSTITUTABLE:
23731           case SUCCESSFUL:
23732           case SUM:
23733           case SYNONYM:
23734           case SYSDATE:
23735           case SYS_REFCURSOR:
23736           case TABLE:
23737           case TEMPORARY:
23738           case THEN:
23739           case TIME:
23740           case TIMESTAMP:
23741           case TIMEZONE_REGION:
23742           case TIMEZONE_ABBR:
23743           case TIMEZONE_MINUTE:
23744           case TIMEZONE_HOUR:
23745           case TO:
23746           case TRANSACTION:
23747           case TRIGGER:
23748           case TRUE:
23749           case TYPE:
23750           case UI:
23751           case UNDER:
23752           case USING:
23753           case WHILE:
23754           case YES:
23755           case SHOW:
23756           case A:
23757           case UPDATE:
23758           case VARCHAR:
23759           case VARCHAR2:
23760           case DOUBLE:
23761           case DEC:
23762           case PRECISION:
23763           case INT:
23764           case NUMERIC:
23765           case SIGNTYPE:
23766           case NCHAR:
23767           case NVARCHAR2:
23768           case STRING:
23769           case UROWID:
23770           case VARRAY:
23771           case VARYING:
23772           case BFILE:
23773           case BLOB:
23774           case CLOB:
23775           case NCLOB:
23776           case YEAR:
23777           case LOCAL:
23778           case WITH:
23779           case ZONE:
23780           case CHARACTER:
23781           case AFTER:
23782           case BEFORE:
23783           case OLD:
23784           case PARENT:
23785           case ANALYZE:
23786           case ASSOCIATE:
23787           case AUDIT:
23788           case COMPOUND:
23789           case DATABASE:
23790           case CALL:
23791           case DDL:
23792           case DISASSOCIATE:
23793           case EACH:
23794           case FOLLOWS:
23795           case LOGOFF:
23796           case LOGON:
23797           case NESTED:
23798           case NOAUDIT:
23799           case SCHEMA:
23800           case SERVERERROR:
23801           case SHUTDOWN:
23802           case STARTUP:
23803           case STATEMENT:
23804           case STATISTICS:
23805           case SUSPEND:
23806           case TRUNCATE:
23807           case WRAPPED:
23808           case LIBRARY:
23809           case NAME:
23810           case STRUCT:
23811           case CONTEXT:
23812           case PARAMETERS:
23813           case LENGTH:
23814           case TDO:
23815           case MAXLEN:
23816           case CHARSETID:
23817           case CHARSETFORM:
23818           case ACCEPT:
23819           case ACCESSIBLE:
23820           case COPY:
23821           case DEFINE:
23822           case DISCONNECT:
23823           case HOST:
23824           case PRINT:
23825           case QUIT:
23826           case REMARK:
23827           case UNDEFINE:
23828           case VARIABLE:
23829           case WHENEVER:
23830           case ATTACH:
23831           case CAST:
23832           case TREAT:
23833           case TRIM:
23834           case LEFT:
23835           case RIGHT:
23836           case BOTH:
23837           case EMPTY:
23838           case MULTISET:
23839           case SUBMULTISET:
23840           case LEADING:
23841           case TRAILING:
23842           case CHAR_CS:
23843           case NCHAR_CS:
23844           case DBTIMEZONE:
23845           case SESSIONTIMEZONE:
23846           case AUTHENTICATED:
23847           case LINK:
23848           case SHARED:
23849           case DIRECTORY:
23850           case USER:
23851           case IDENTIFIER:
23852           case QUOTED_LITERAL:
23853           case SQLDATA_CLASS:
23854           case CUSTOMDATUM_CLASS:
23855           case ORADATA_CLASS:
23856           case JAVA_INTERFACE_CLASS:
23857             ID();
23858             break;
23859           default:
23860             jj_la1[326] = jj_gen;
23861             ;
23862           }
23863           jj_consume_token(4);
23864           break;
23865         default:
23866           jj_la1[327] = jj_gen;
23867           jj_consume_token(-1);
23868           throw new ParseException();
23869         }
23870         break;
23871       default:
23872         jj_la1[328] = jj_gen;
23873         ;
23874       }
23875         jjtree.closeNodeScope(jjtn000, true);
23876         jjtc000 = false;
23877         {if (true) return jjtn000 ;}
23878     } catch (Throwable jjte000) {
23879           if (jjtc000) {
23880             jjtree.clearNodeScope(jjtn000);
23881             jjtc000 = false;
23882           } else {
23883             jjtree.popNode();
23884           }
23885           if (jjte000 instanceof RuntimeException) {
23886             {if (true) throw (RuntimeException)jjte000;}
23887           }
23888           if (jjte000 instanceof ParseException) {
23889             {if (true) throw (ParseException)jjte000;}
23890           }
23891           {if (true) throw (Error)jjte000;}
23892     } finally {
23893           if (jjtc000) {
23894             jjtree.closeNodeScope(jjtn000, true);
23895           }
23896     }
23897     throw new Error("Missing return statement in function");
23898   }
23899 
23900   final public ASTTypeSpecification TypeSpecification() throws ParseException {
23901  /*@bgen(jjtree) TypeSpecification */
23902  ASTTypeSpecification jjtn000 = new ASTTypeSpecification(this, JJTTYPESPECIFICATION);
23903  boolean jjtc000 = true;
23904  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
23905     try {
23906       switch (jj_nt.kind) {
23907       case CREATE:
23908         jj_consume_token(CREATE);
23909         switch (jj_nt.kind) {
23910         case OR:
23911           jj_consume_token(OR);
23912           jj_consume_token(REPLACE);
23913           break;
23914         default:
23915           jj_la1[329] = jj_gen;
23916           ;
23917         }
23918         switch (jj_nt.kind) {
23919         case EDITIONABLE:
23920         case NONEDITIONABLE:
23921           switch (jj_nt.kind) {
23922           case EDITIONABLE:
23923             jj_consume_token(EDITIONABLE);
23924             break;
23925           case NONEDITIONABLE:
23926             jj_consume_token(NONEDITIONABLE);
23927             break;
23928           default:
23929             jj_la1[330] = jj_gen;
23930             jj_consume_token(-1);
23931             throw new ParseException();
23932           }
23933           break;
23934         default:
23935           jj_la1[331] = jj_gen;
23936           ;
23937         }
23938         break;
23939       default:
23940         jj_la1[332] = jj_gen;
23941         ;
23942       }
23943       jj_consume_token(TYPE);
23944       simpleNode = ObjectNameDeclaration();
23945       switch (jj_nt.kind) {
23946       case FORCE:
23947         jj_consume_token(FORCE);
23948         break;
23949       default:
23950         jj_la1[333] = jj_gen;
23951         ;
23952       }
23953       if (jj_2_61(2)) {
23954         jj_consume_token(OID);
23955         jj_consume_token(STRING_LITERAL);
23956       } else {
23957         ;
23958       }
23959       label_74:
23960       while (true) {
23961         if (jj_2_62(2)) {
23962           ;
23963         } else {
23964           break label_74;
23965         }
23966         switch (jj_nt.kind) {
23967         case AUTHID:
23968           jj_consume_token(AUTHID);
23969           switch (jj_nt.kind) {
23970           case CURRENT_USER:
23971             jj_consume_token(CURRENT_USER);
23972             break;
23973           case DEFINER:
23974             jj_consume_token(DEFINER);
23975             break;
23976           default:
23977             jj_la1[334] = jj_gen;
23978             jj_consume_token(-1);
23979             throw new ParseException();
23980           }
23981           break;
23982         case ACCESSIBLE:
23983           AccessibleByClause();
23984           break;
23985         default:
23986           jj_la1[335] = jj_gen;
23987           jj_consume_token(-1);
23988           throw new ParseException();
23989         }
23990       }
23991       switch (jj_nt.kind) {
23992       case AS:
23993       case IS:
23994       case UNDER:
23995         switch (jj_nt.kind) {
23996         case UNDER:
23997           jj_consume_token(UNDER);
23998           ObjectNameDeclaration();
23999           break;
24000         default:
24001           jj_la1[342] = jj_gen;
24002           if (jj_2_63(2)) {
24003             switch (jj_nt.kind) {
24004             case IS:
24005               jj_consume_token(IS);
24006               break;
24007             case AS:
24008               jj_consume_token(AS);
24009               break;
24010             default:
24011               jj_la1[336] = jj_gen;
24012               jj_consume_token(-1);
24013               throw new ParseException();
24014             }
24015             jj_consume_token(OBJECT);
24016           } else if (jj_2_64(2)) {
24017             switch (jj_nt.kind) {
24018             case IS:
24019               jj_consume_token(IS);
24020               break;
24021             case AS:
24022               jj_consume_token(AS);
24023               break;
24024             default:
24025               jj_la1[337] = jj_gen;
24026               jj_consume_token(-1);
24027               throw new ParseException();
24028             }
24029             jj_consume_token(OPAQUE);
24030             jj_consume_token(VARYING);
24031             jj_consume_token(24);
24032             jj_consume_token(USING);
24033             jj_consume_token(LIBRARY);
24034             switch (jj_nt.kind) {
24035             case IDENTIFIER:
24036               jj_consume_token(IDENTIFIER);
24037               break;
24038             case QUOTED_LITERAL:
24039               jj_consume_token(QUOTED_LITERAL);
24040               break;
24041             case STRING_LITERAL:
24042               StringLiteral();
24043               break;
24044             default:
24045               jj_la1[338] = jj_gen;
24046               jj_consume_token(-1);
24047               throw new ParseException();
24048             }
24049             switch (jj_nt.kind) {
24050             case 3:
24051               jj_consume_token(3);
24052               switch (jj_nt.kind) {
24053               case IDENTIFIER:
24054                 jj_consume_token(IDENTIFIER);
24055                 break;
24056               case QUOTED_LITERAL:
24057                 jj_consume_token(QUOTED_LITERAL);
24058                 break;
24059               case STRING_LITERAL:
24060                 StringLiteral();
24061                 break;
24062               default:
24063                 jj_la1[339] = jj_gen;
24064                 jj_consume_token(-1);
24065                 throw new ParseException();
24066               }
24067               break;
24068             default:
24069               jj_la1[340] = jj_gen;
24070               ;
24071             }
24072           } else if (jj_2_65(2)) {
24073             switch (jj_nt.kind) {
24074             case IS:
24075               jj_consume_token(IS);
24076               break;
24077             case AS:
24078               jj_consume_token(AS);
24079               break;
24080             default:
24081               jj_la1[341] = jj_gen;
24082               jj_consume_token(-1);
24083               throw new ParseException();
24084             }
24085             CollectionTypeName();
24086             jj_consume_token(OF);
24087             Datatype();
24088           } else {
24089             jj_consume_token(-1);
24090             throw new ParseException();
24091           }
24092         }
24093         break;
24094       default:
24095         jj_la1[343] = jj_gen;
24096         ;
24097       }
24098       if (jj_2_66(8)) {
24099         jj_consume_token(EXTERNAL);
24100         jj_consume_token(IDENTIFIER);
24101         jj_consume_token(IDENTIFIER);
24102         jj_consume_token(LANGUAGE);
24103         jj_consume_token(JAVA);
24104         jj_consume_token(USING);
24105         jj_consume_token(IDENTIFIER);
24106       } else {
24107         ;
24108       }
24109       switch (jj_nt.kind) {
24110       case WRAPPED:
24111         WrappedObject();
24112         break;
24113       default:
24114         jj_la1[344] = jj_gen;
24115         ;
24116       }
24117       switch (jj_nt.kind) {
24118       case 5:
24119         jj_consume_token(5);
24120         label_75:
24121         while (true) {
24122           switch (jj_nt.kind) {
24123           case REPLACE:
24124           case DEFINER:
24125           case CURRENT_USER:
24126           case SERIALLY_REUSABLE:
24127           case RESTRICT_REFERENCES:
24128           case EXCEPTION_INIT:
24129           case AUTONOMOUS_TRANSACTION:
24130           case LANGUAGE:
24131           case ADD:
24132           case AGGREGATE:
24133           case ALL:
24134           case ALTER:
24135           case AND:
24136           case ANY:
24137           case ARRAY:
24138           case AS:
24139           case ASC:
24140           case AT:
24141           case ATTRIBUTE:
24142           case AUTHID:
24143           case AVG:
24144           case BETWEEN:
24145           case BINARY_INTEGER:
24146           case BODY:
24147           case BOOLEAN:
24148           case BULK:
24149           case BY:
24150           case BYTE:
24151           case CASCADE:
24152           case CASE:
24153           case CHAR:
24154           case CHAR_BASE:
24155           case CHECK:
24156           case CLOSE:
24157           case CLUSTER:
24158           case COALESCE:
24159           case COLLECT:
24160           case COLUMN:
24161           case COMMENT:
24162           case COMMIT:
24163           case COMPRESS:
24164           case CONNECT:
24165           case CONSTANT:
24166           case CONSTRUCTOR:
24167           case CONTINUE:
24168           case CONVERT:
24169           case CREATE:
24170           case CURRENT:
24171           case CURRVAL:
24172           case CURSOR:
24173           case DATA:
24174           case DATE:
24175           case DAY:
24176           case DECLARE:
24177           case DECIMAL:
24178           case _DEFAULT:
24179           case DELETE:
24180           case DESC:
24181           case DISABLE:
24182           case DISTINCT:
24183           case DO:
24184           case DROP:
24185           case EDITIONABLE:
24186           case ELEMENT:
24187           case ELSE:
24188           case ELSIF:
24189           case ENABLE:
24190           case ESCAPE:
24191           case EXCEPT:
24192           case EXCEPTION:
24193           case EXCEPTIONS:
24194           case EXCLUSIVE:
24195           case EXECUTE:
24196           case EXISTS:
24197           case EXIT:
24198           case EXTERNAL:
24199           case EXTENDS:
24200           case EXTRACT:
24201           case FALSE:
24202           case FETCH:
24203           case FINAL:
24204           case FLOAT:
24205           case FOR:
24206           case FORALL:
24207           case FORCE:
24208           case FROM:
24209           case FUNCTION:
24210           case GLOBAL:
24211           case GOTO:
24212           case GROUP:
24213           case HASH:
24214           case HAVING:
24215           case HEAP:
24216           case HOUR:
24217           case IF:
24218           case IMMEDIATE:
24219           case IN:
24220           case INDEX:
24221           case INDICES:
24222           case INDEXTYPE:
24223           case INDICATOR:
24224           case INSERT:
24225           case INSTANTIABLE:
24226           case INTEGER:
24227           case INTERFACE:
24228           case INTERSECT:
24229           case INTERVAL:
24230           case INTO:
24231           case INVALIDATE:
24232           case IS:
24233           case ISOLATION:
24234           case JAVA:
24235           case LEVEL:
24236           case LIKE:
24237           case LIMIT:
24238           case LIMITED:
24239           case LOCK:
24240           case LONG:
24241           case LOOP:
24242           case MAP:
24243           case MAX:
24244           case MEMBER:
24245           case MERGE:
24246           case MIN:
24247           case MINUS:
24248           case MINUTE:
24249           case MLSLABEL:
24250           case MODIFY:
24251           case MOD:
24252           case MODE:
24253           case MONTH:
24254           case NATURAL:
24255           case NATURALN:
24256           case NEW:
24257           case NEXTVAL:
24258           case NO:
24259           case NOCOPY:
24260           case NONEDITIONABLE:
24261           case NOT:
24262           case NOWAIT:
24263           case NULL:
24264           case NULLIF:
24265           case NUMBER:
24266           case BFILE_BASE:
24267           case BLOB_BASE:
24268           case CLOB_BASE:
24269           case DATE_BASE:
24270           case NUMBER_BASE:
24271           case OBJECT:
24272           case OCIROWID:
24273           case OF:
24274           case OID:
24275           case ON:
24276           case OPAQUE:
24277           case OPEN:
24278           case OPERATOR:
24279           case OPTION:
24280           case OR:
24281           case ORDER:
24282           case ORGANIZATION:
24283           case OTHERS:
24284           case OUT:
24285           case OVERRIDING:
24286           case PACKAGE:
24287           case PARTITION:
24288           case PCTFREE:
24289           case PLS_INTEGER:
24290           case POSITIVE:
24291           case POSITIVEN:
24292           case PRAGMA:
24293           case PRESERVE:
24294           case PRIOR:
24295           case PROMPT:
24296           case PRIVATE:
24297           case PROCEDURE:
24298           case PUBLIC:
24299           case RAISE:
24300           case RANGE:
24301           case RAW:
24302           case REAL:
24303           case RECORD:
24304           case REF:
24305           case RELEASE:
24306           case RELIES_ON:
24307           case RENAME:
24308           case RESULT:
24309           case RETURN:
24310           case RETURNING:
24311           case REVERSE:
24312           case ROLLBACK:
24313           case ROW:
24314           case ROWS:
24315           case ROWID:
24316           case ROWNUM:
24317           case ROWTYPE:
24318           case SAVE:
24319           case SAVEPOINT:
24320           case SECOND:
24321           case SELECT:
24322           case SELF:
24323           case SEPARATE:
24324           case SET:
24325           case SHARE:
24326           case SMALLINT:
24327           case SPACE:
24328           case SQL:
24329           case SQLCODE:
24330           case SQLERRM:
24331           case START:
24332           case STATIC:
24333           case STDDEV:
24334           case SUBTYPE:
24335           case SUBSTITUTABLE:
24336           case SUCCESSFUL:
24337           case SUM:
24338           case SYNONYM:
24339           case SYSDATE:
24340           case SYS_REFCURSOR:
24341           case TABLE:
24342           case TEMPORARY:
24343           case THEN:
24344           case TIME:
24345           case TIMESTAMP:
24346           case TIMEZONE_REGION:
24347           case TIMEZONE_ABBR:
24348           case TIMEZONE_MINUTE:
24349           case TIMEZONE_HOUR:
24350           case TO:
24351           case TRANSACTION:
24352           case TRIGGER:
24353           case TRUE:
24354           case TYPE:
24355           case UI:
24356           case UNDER:
24357           case USING:
24358           case WHILE:
24359           case YES:
24360           case SHOW:
24361           case A:
24362           case UPDATE:
24363           case VARCHAR:
24364           case VARCHAR2:
24365           case DOUBLE:
24366           case DEC:
24367           case PRECISION:
24368           case INT:
24369           case NUMERIC:
24370           case SIGNTYPE:
24371           case NCHAR:
24372           case NVARCHAR2:
24373           case STRING:
24374           case UROWID:
24375           case VARRAY:
24376           case VARYING:
24377           case BFILE:
24378           case BLOB:
24379           case CLOB:
24380           case NCLOB:
24381           case YEAR:
24382           case LOCAL:
24383           case WITH:
24384           case ZONE:
24385           case CHARACTER:
24386           case AFTER:
24387           case BEFORE:
24388           case OLD:
24389           case PARENT:
24390           case ANALYZE:
24391           case ASSOCIATE:
24392           case AUDIT:
24393           case COMPOUND:
24394           case DATABASE:
24395           case CALL:
24396           case DDL:
24397           case DISASSOCIATE:
24398           case EACH:
24399           case FOLLOWS:
24400           case LOGOFF:
24401           case LOGON:
24402           case NESTED:
24403           case NOAUDIT:
24404           case SCHEMA:
24405           case SERVERERROR:
24406           case SHUTDOWN:
24407           case STARTUP:
24408           case STATEMENT:
24409           case STATISTICS:
24410           case SUSPEND:
24411           case TRUNCATE:
24412           case WRAPPED:
24413           case LIBRARY:
24414           case NAME:
24415           case STRUCT:
24416           case CONTEXT:
24417           case PARAMETERS:
24418           case LENGTH:
24419           case TDO:
24420           case MAXLEN:
24421           case CHARSETID:
24422           case CHARSETFORM:
24423           case ACCEPT:
24424           case ACCESSIBLE:
24425           case COPY:
24426           case DEFINE:
24427           case DISCONNECT:
24428           case HOST:
24429           case PRINT:
24430           case QUIT:
24431           case REMARK:
24432           case UNDEFINE:
24433           case VARIABLE:
24434           case WHENEVER:
24435           case ATTACH:
24436           case CAST:
24437           case TREAT:
24438           case TRIM:
24439           case LEFT:
24440           case RIGHT:
24441           case BOTH:
24442           case EMPTY:
24443           case MULTISET:
24444           case SUBMULTISET:
24445           case LEADING:
24446           case TRAILING:
24447           case CHAR_CS:
24448           case NCHAR_CS:
24449           case DBTIMEZONE:
24450           case SESSIONTIMEZONE:
24451           case AUTHENTICATED:
24452           case LINK:
24453           case SHARED:
24454           case DIRECTORY:
24455           case USER:
24456           case IDENTIFIER:
24457           case QUOTED_LITERAL:
24458           case SQLDATA_CLASS:
24459           case CUSTOMDATUM_CLASS:
24460           case ORADATA_CLASS:
24461           case JAVA_INTERFACE_CLASS:
24462             ;
24463             break;
24464           default:
24465             jj_la1[345] = jj_gen;
24466             break label_75;
24467           }
24468           if (jj_2_67(2)) {
24469             TypeMethod();
24470           } else {
24471             switch (jj_nt.kind) {
24472             case REPLACE:
24473             case DEFINER:
24474             case CURRENT_USER:
24475             case SERIALLY_REUSABLE:
24476             case RESTRICT_REFERENCES:
24477             case EXCEPTION_INIT:
24478             case AUTONOMOUS_TRANSACTION:
24479             case LANGUAGE:
24480             case ADD:
24481             case AGGREGATE:
24482             case ALL:
24483             case ALTER:
24484             case AND:
24485             case ANY:
24486             case ARRAY:
24487             case AS:
24488             case ASC:
24489             case AT:
24490             case ATTRIBUTE:
24491             case AUTHID:
24492             case AVG:
24493             case BETWEEN:
24494             case BINARY_INTEGER:
24495             case BODY:
24496             case BOOLEAN:
24497             case BULK:
24498             case BY:
24499             case BYTE:
24500             case CASCADE:
24501             case CASE:
24502             case CHAR:
24503             case CHAR_BASE:
24504             case CHECK:
24505             case CLOSE:
24506             case CLUSTER:
24507             case COALESCE:
24508             case COLLECT:
24509             case COLUMN:
24510             case COMMENT:
24511             case COMMIT:
24512             case COMPRESS:
24513             case CONNECT:
24514             case CONSTANT:
24515             case CONSTRUCTOR:
24516             case CONTINUE:
24517             case CONVERT:
24518             case CREATE:
24519             case CURRENT:
24520             case CURRVAL:
24521             case CURSOR:
24522             case DATA:
24523             case DATE:
24524             case DAY:
24525             case DECLARE:
24526             case DECIMAL:
24527             case _DEFAULT:
24528             case DELETE:
24529             case DESC:
24530             case DISABLE:
24531             case DISTINCT:
24532             case DO:
24533             case DROP:
24534             case EDITIONABLE:
24535             case ELEMENT:
24536             case ELSE:
24537             case ELSIF:
24538             case ENABLE:
24539             case ESCAPE:
24540             case EXCEPT:
24541             case EXCEPTION:
24542             case EXCEPTIONS:
24543             case EXCLUSIVE:
24544             case EXECUTE:
24545             case EXISTS:
24546             case EXIT:
24547             case EXTERNAL:
24548             case EXTENDS:
24549             case EXTRACT:
24550             case FALSE:
24551             case FETCH:
24552             case FINAL:
24553             case FLOAT:
24554             case FOR:
24555             case FORALL:
24556             case FORCE:
24557             case FROM:
24558             case FUNCTION:
24559             case GLOBAL:
24560             case GOTO:
24561             case GROUP:
24562             case HASH:
24563             case HAVING:
24564             case HEAP:
24565             case HOUR:
24566             case IF:
24567             case IMMEDIATE:
24568             case IN:
24569             case INDEX:
24570             case INDICES:
24571             case INDEXTYPE:
24572             case INDICATOR:
24573             case INSERT:
24574             case INSTANTIABLE:
24575             case INTEGER:
24576             case INTERFACE:
24577             case INTERSECT:
24578             case INTERVAL:
24579             case INTO:
24580             case INVALIDATE:
24581             case IS:
24582             case ISOLATION:
24583             case JAVA:
24584             case LEVEL:
24585             case LIKE:
24586             case LIMIT:
24587             case LIMITED:
24588             case LOCK:
24589             case LONG:
24590             case LOOP:
24591             case MAP:
24592             case MAX:
24593             case MEMBER:
24594             case MERGE:
24595             case MIN:
24596             case MINUS:
24597             case MINUTE:
24598             case MLSLABEL:
24599             case MODIFY:
24600             case MOD:
24601             case MODE:
24602             case MONTH:
24603             case NATURAL:
24604             case NATURALN:
24605             case NEW:
24606             case NEXTVAL:
24607             case NO:
24608             case NOCOPY:
24609             case NONEDITIONABLE:
24610             case NOT:
24611             case NOWAIT:
24612             case NULL:
24613             case NULLIF:
24614             case NUMBER:
24615             case BFILE_BASE:
24616             case BLOB_BASE:
24617             case CLOB_BASE:
24618             case DATE_BASE:
24619             case NUMBER_BASE:
24620             case OBJECT:
24621             case OCIROWID:
24622             case OF:
24623             case OID:
24624             case ON:
24625             case OPAQUE:
24626             case OPEN:
24627             case OPERATOR:
24628             case OPTION:
24629             case OR:
24630             case ORDER:
24631             case ORGANIZATION:
24632             case OTHERS:
24633             case OUT:
24634             case OVERRIDING:
24635             case PACKAGE:
24636             case PARTITION:
24637             case PCTFREE:
24638             case PLS_INTEGER:
24639             case POSITIVE:
24640             case POSITIVEN:
24641             case PRESERVE:
24642             case PRIOR:
24643             case PROMPT:
24644             case PRIVATE:
24645             case PROCEDURE:
24646             case PUBLIC:
24647             case RAISE:
24648             case RANGE:
24649             case RAW:
24650             case REAL:
24651             case RECORD:
24652             case REF:
24653             case RELEASE:
24654             case RELIES_ON:
24655             case RENAME:
24656             case RESULT:
24657             case RETURN:
24658             case RETURNING:
24659             case REVERSE:
24660             case ROLLBACK:
24661             case ROW:
24662             case ROWS:
24663             case ROWID:
24664             case ROWNUM:
24665             case ROWTYPE:
24666             case SAVE:
24667             case SAVEPOINT:
24668             case SECOND:
24669             case SELECT:
24670             case SELF:
24671             case SEPARATE:
24672             case SET:
24673             case SHARE:
24674             case SMALLINT:
24675             case SPACE:
24676             case SQL:
24677             case SQLCODE:
24678             case SQLERRM:
24679             case START:
24680             case STATIC:
24681             case STDDEV:
24682             case SUBTYPE:
24683             case SUBSTITUTABLE:
24684             case SUCCESSFUL:
24685             case SUM:
24686             case SYNONYM:
24687             case SYSDATE:
24688             case SYS_REFCURSOR:
24689             case TABLE:
24690             case TEMPORARY:
24691             case THEN:
24692             case TIME:
24693             case TIMESTAMP:
24694             case TIMEZONE_REGION:
24695             case TIMEZONE_ABBR:
24696             case TIMEZONE_MINUTE:
24697             case TIMEZONE_HOUR:
24698             case TO:
24699             case TRANSACTION:
24700             case TRIGGER:
24701             case TRUE:
24702             case TYPE:
24703             case UI:
24704             case UNDER:
24705             case USING:
24706             case WHILE:
24707             case YES:
24708             case SHOW:
24709             case A:
24710             case UPDATE:
24711             case VARCHAR:
24712             case VARCHAR2:
24713             case DOUBLE:
24714             case DEC:
24715             case PRECISION:
24716             case INT:
24717             case NUMERIC:
24718             case SIGNTYPE:
24719             case NCHAR:
24720             case NVARCHAR2:
24721             case STRING:
24722             case UROWID:
24723             case VARRAY:
24724             case VARYING:
24725             case BFILE:
24726             case BLOB:
24727             case CLOB:
24728             case NCLOB:
24729             case YEAR:
24730             case LOCAL:
24731             case WITH:
24732             case ZONE:
24733             case CHARACTER:
24734             case AFTER:
24735             case BEFORE:
24736             case OLD:
24737             case PARENT:
24738             case ANALYZE:
24739             case ASSOCIATE:
24740             case AUDIT:
24741             case COMPOUND:
24742             case DATABASE:
24743             case CALL:
24744             case DDL:
24745             case DISASSOCIATE:
24746             case EACH:
24747             case FOLLOWS:
24748             case LOGOFF:
24749             case LOGON:
24750             case NESTED:
24751             case NOAUDIT:
24752             case SCHEMA:
24753             case SERVERERROR:
24754             case SHUTDOWN:
24755             case STARTUP:
24756             case STATEMENT:
24757             case STATISTICS:
24758             case SUSPEND:
24759             case TRUNCATE:
24760             case WRAPPED:
24761             case LIBRARY:
24762             case NAME:
24763             case STRUCT:
24764             case CONTEXT:
24765             case PARAMETERS:
24766             case LENGTH:
24767             case TDO:
24768             case MAXLEN:
24769             case CHARSETID:
24770             case CHARSETFORM:
24771             case ACCEPT:
24772             case ACCESSIBLE:
24773             case COPY:
24774             case DEFINE:
24775             case DISCONNECT:
24776             case HOST:
24777             case PRINT:
24778             case QUIT:
24779             case REMARK:
24780             case UNDEFINE:
24781             case VARIABLE:
24782             case WHENEVER:
24783             case ATTACH:
24784             case CAST:
24785             case TREAT:
24786             case TRIM:
24787             case LEFT:
24788             case RIGHT:
24789             case BOTH:
24790             case EMPTY:
24791             case MULTISET:
24792             case SUBMULTISET:
24793             case LEADING:
24794             case TRAILING:
24795             case CHAR_CS:
24796             case NCHAR_CS:
24797             case DBTIMEZONE:
24798             case SESSIONTIMEZONE:
24799             case AUTHENTICATED:
24800             case LINK:
24801             case SHARED:
24802             case DIRECTORY:
24803             case USER:
24804             case IDENTIFIER:
24805             case QUOTED_LITERAL:
24806             case SQLDATA_CLASS:
24807             case CUSTOMDATUM_CLASS:
24808             case ORADATA_CLASS:
24809             case JAVA_INTERFACE_CLASS:
24810               AttributeDeclaration();
24811               break;
24812             case PRAGMA:
24813               PragmaClause();
24814               break;
24815             default:
24816               jj_la1[346] = jj_gen;
24817               jj_consume_token(-1);
24818               throw new ParseException();
24819             }
24820           }
24821         }
24822         label_76:
24823         while (true) {
24824           switch (jj_nt.kind) {
24825           case 6:
24826             ;
24827             break;
24828           default:
24829             jj_la1[347] = jj_gen;
24830             break label_76;
24831           }
24832           jj_consume_token(6);
24833           switch (jj_nt.kind) {
24834           case CONSTRUCTOR:
24835           case FINAL:
24836           case INSTANTIABLE:
24837           case MAP:
24838           case MEMBER:
24839           case NOT:
24840           case ORDER:
24841           case OVERRIDING:
24842           case STATIC:
24843             TypeMethod();
24844             break;
24845           default:
24846             jj_la1[348] = jj_gen;
24847             if (jj_2_68(2)) {
24848               AttributeDeclaration();
24849             } else {
24850               switch (jj_nt.kind) {
24851               case PRAGMA:
24852                 PragmaClause();
24853                 break;
24854               default:
24855                 jj_la1[349] = jj_gen;
24856                 jj_consume_token(-1);
24857                 throw new ParseException();
24858               }
24859             }
24860           }
24861         }
24862         jj_consume_token(7);
24863         break;
24864       default:
24865         jj_la1[350] = jj_gen;
24866         ;
24867       }
24868       label_77:
24869       while (true) {
24870         switch (jj_nt.kind) {
24871         case FINAL:
24872         case INSTANTIABLE:
24873         case NOT:
24874         case NULL:
24875           ;
24876           break;
24877         default:
24878           jj_la1[351] = jj_gen;
24879           break label_77;
24880         }
24881         switch (jj_nt.kind) {
24882         case NOT:
24883           jj_consume_token(NOT);
24884           break;
24885         default:
24886           jj_la1[352] = jj_gen;
24887           ;
24888         }
24889         switch (jj_nt.kind) {
24890         case FINAL:
24891           jj_consume_token(FINAL);
24892           break;
24893         case INSTANTIABLE:
24894           jj_consume_token(INSTANTIABLE);
24895           break;
24896         case NULL:
24897           jj_consume_token(NULL);
24898           break;
24899         default:
24900           jj_la1[353] = jj_gen;
24901           jj_consume_token(-1);
24902           throw new ParseException();
24903         }
24904       }
24905       label_78:
24906       while (true) {
24907         switch (jj_nt.kind) {
24908         case ALTER:
24909           ;
24910           break;
24911         default:
24912           jj_la1[354] = jj_gen;
24913           break label_78;
24914         }
24915         AlterTypeSpec();
24916       }
24917       switch (jj_nt.kind) {
24918       case 1:
24919       case 4:
24920         switch (jj_nt.kind) {
24921         case 4:
24922           jj_consume_token(4);
24923           break;
24924         case 1:
24925           jj_consume_token(1);
24926           break;
24927         default:
24928           jj_la1[355] = jj_gen;
24929           jj_consume_token(-1);
24930           throw new ParseException();
24931         }
24932         label_79:
24933         while (true) {
24934           switch (jj_nt.kind) {
24935           case ALTER:
24936             ;
24937             break;
24938           default:
24939             jj_la1[356] = jj_gen;
24940             break label_79;
24941           }
24942           AlterTypeSpec();
24943           switch (jj_nt.kind) {
24944           case 1:
24945             jj_consume_token(1);
24946             break;
24947           case 4:
24948             jj_consume_token(4);
24949             break;
24950           default:
24951             jj_la1[357] = jj_gen;
24952             jj_consume_token(-1);
24953             throw new ParseException();
24954           }
24955         }
24956         break;
24957       default:
24958         jj_la1[358] = jj_gen;
24959         ;
24960       }
24961         jjtree.closeNodeScope(jjtn000, true);
24962         jjtc000 = false;
24963         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
24964     } catch (Throwable jjte000) {
24965           if (jjtc000) {
24966             jjtree.clearNodeScope(jjtn000);
24967             jjtc000 = false;
24968           } else {
24969             jjtree.popNode();
24970           }
24971           if (jjte000 instanceof RuntimeException) {
24972             {if (true) throw (RuntimeException)jjte000;}
24973           }
24974           if (jjte000 instanceof ParseException) {
24975             {if (true) throw (ParseException)jjte000;}
24976           }
24977           {if (true) throw (Error)jjte000;}
24978     } finally {
24979           if (jjtc000) {
24980             jjtree.closeNodeScope(jjtn000, true);
24981           }
24982     }
24983     throw new Error("Missing return statement in function");
24984   }
24985 
24986   final public ASTAlterTypeSpec AlterTypeSpec() throws ParseException {
24987  /*@bgen(jjtree) AlterTypeSpec */
24988  ASTAlterTypeSpec jjtn000 = new ASTAlterTypeSpec(this, JJTALTERTYPESPEC);
24989  boolean jjtc000 = true;
24990  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
24991     try {
24992       jj_consume_token(ALTER);
24993       jj_consume_token(TYPE);
24994       simpleNode = QualifiedName();
24995       label_80:
24996       while (true) {
24997         switch (jj_nt.kind) {
24998         case 6:
24999         case ADD:
25000         case DROP:
25001         case MODIFY:
25002           ;
25003           break;
25004         default:
25005           jj_la1[359] = jj_gen;
25006           break label_80;
25007         }
25008         switch (jj_nt.kind) {
25009         case 6:
25010         case ADD:
25011         case MODIFY:
25012           switch (jj_nt.kind) {
25013           case 6:
25014             jj_consume_token(6);
25015             break;
25016           default:
25017             jj_la1[360] = jj_gen;
25018             ;
25019           }
25020           switch (jj_nt.kind) {
25021           case ADD:
25022             jj_consume_token(ADD);
25023             break;
25024           case MODIFY:
25025             jj_consume_token(MODIFY);
25026             break;
25027           default:
25028             jj_la1[361] = jj_gen;
25029             jj_consume_token(-1);
25030             throw new ParseException();
25031           }
25032           label_81:
25033           while (true) {
25034             switch (jj_nt.kind) {
25035             case CONSTRUCTOR:
25036             case FINAL:
25037             case INSTANTIABLE:
25038             case MAP:
25039             case MEMBER:
25040             case NOT:
25041             case ORDER:
25042             case OVERRIDING:
25043             case STATIC:
25044               TypeMethod();
25045               break;
25046             case ATTRIBUTE:
25047               jj_consume_token(ATTRIBUTE);
25048               label_82:
25049               while (true) {
25050                 switch (jj_nt.kind) {
25051                 case 5:
25052                   ;
25053                   break;
25054                 default:
25055                   jj_la1[362] = jj_gen;
25056                   break label_82;
25057                 }
25058                 jj_consume_token(5);
25059               }
25060               AttributeDeclaration();
25061               label_83:
25062               while (true) {
25063                 switch (jj_nt.kind) {
25064                 case 6:
25065                   ;
25066                   break;
25067                 default:
25068                   jj_la1[363] = jj_gen;
25069                   break label_83;
25070                 }
25071                 jj_consume_token(6);
25072                 AttributeDeclaration();
25073               }
25074               label_84:
25075               while (true) {
25076                 switch (jj_nt.kind) {
25077                 case 7:
25078                   ;
25079                   break;
25080                 default:
25081                   jj_la1[364] = jj_gen;
25082                   break label_84;
25083                 }
25084                 jj_consume_token(7);
25085               }
25086               break;
25087             case LIMIT:
25088               jj_consume_token(LIMIT);
25089               NumericLiteral();
25090               break;
25091             case ELEMENT:
25092               jj_consume_token(ELEMENT);
25093               jj_consume_token(TYPE);
25094               Datatype();
25095               break;
25096             default:
25097               jj_la1[365] = jj_gen;
25098               jj_consume_token(-1);
25099               throw new ParseException();
25100             }
25101             switch (jj_nt.kind) {
25102             case ATTRIBUTE:
25103             case CONSTRUCTOR:
25104             case ELEMENT:
25105             case FINAL:
25106             case INSTANTIABLE:
25107             case LIMIT:
25108             case MAP:
25109             case MEMBER:
25110             case NOT:
25111             case ORDER:
25112             case OVERRIDING:
25113             case STATIC:
25114               ;
25115               break;
25116             default:
25117               jj_la1[366] = jj_gen;
25118               break label_81;
25119             }
25120           }
25121           break;
25122         case DROP:
25123           jj_consume_token(DROP);
25124           label_85:
25125           while (true) {
25126             switch (jj_nt.kind) {
25127             case ATTRIBUTE:
25128               jj_consume_token(ATTRIBUTE);
25129               label_86:
25130               while (true) {
25131                 switch (jj_nt.kind) {
25132                 case 5:
25133                   ;
25134                   break;
25135                 default:
25136                   jj_la1[367] = jj_gen;
25137                   break label_86;
25138                 }
25139                 jj_consume_token(5);
25140               }
25141               Attribute();
25142               label_87:
25143               while (true) {
25144                 switch (jj_nt.kind) {
25145                 case 6:
25146                   ;
25147                   break;
25148                 default:
25149                   jj_la1[368] = jj_gen;
25150                   break label_87;
25151                 }
25152                 jj_consume_token(6);
25153                 Attribute();
25154               }
25155               label_88:
25156               while (true) {
25157                 switch (jj_nt.kind) {
25158                 case 7:
25159                   ;
25160                   break;
25161                 default:
25162                   jj_la1[369] = jj_gen;
25163                   break label_88;
25164                 }
25165                 jj_consume_token(7);
25166               }
25167               break;
25168             case CONSTRUCTOR:
25169             case FINAL:
25170             case INSTANTIABLE:
25171             case MAP:
25172             case MEMBER:
25173             case NOT:
25174             case ORDER:
25175             case OVERRIDING:
25176             case STATIC:
25177               TypeMethod();
25178               break;
25179             default:
25180               jj_la1[370] = jj_gen;
25181               jj_consume_token(-1);
25182               throw new ParseException();
25183             }
25184             switch (jj_nt.kind) {
25185             case ATTRIBUTE:
25186             case CONSTRUCTOR:
25187             case FINAL:
25188             case INSTANTIABLE:
25189             case MAP:
25190             case MEMBER:
25191             case NOT:
25192             case ORDER:
25193             case OVERRIDING:
25194             case STATIC:
25195               ;
25196               break;
25197             default:
25198               jj_la1[371] = jj_gen;
25199               break label_85;
25200             }
25201           }
25202           break;
25203         default:
25204           jj_la1[372] = jj_gen;
25205           jj_consume_token(-1);
25206           throw new ParseException();
25207         }
25208       }
25209       switch (jj_nt.kind) {
25210       case REPLACE:
25211         jj_consume_token(REPLACE);
25212         label_89:
25213         while (true) {
25214           if (jj_2_69(2)) {
25215             ;
25216           } else {
25217             break label_89;
25218           }
25219           switch (jj_nt.kind) {
25220           case AUTHID:
25221             jj_consume_token(AUTHID);
25222             switch (jj_nt.kind) {
25223             case CURRENT_USER:
25224               jj_consume_token(CURRENT_USER);
25225               break;
25226             case DEFINER:
25227               jj_consume_token(DEFINER);
25228               break;
25229             default:
25230               jj_la1[373] = jj_gen;
25231               jj_consume_token(-1);
25232               throw new ParseException();
25233             }
25234             break;
25235           case ACCESSIBLE:
25236             AccessibleByClause();
25237             break;
25238           default:
25239             jj_la1[374] = jj_gen;
25240             jj_consume_token(-1);
25241             throw new ParseException();
25242           }
25243         }
25244         switch (jj_nt.kind) {
25245         case IS:
25246           jj_consume_token(IS);
25247           break;
25248         case AS:
25249           jj_consume_token(AS);
25250           break;
25251         default:
25252           jj_la1[375] = jj_gen;
25253           jj_consume_token(-1);
25254           throw new ParseException();
25255         }
25256         jj_consume_token(OBJECT);
25257         jj_consume_token(5);
25258         if (jj_2_70(2)) {
25259           TypeMethod();
25260         } else {
25261           switch (jj_nt.kind) {
25262           case REPLACE:
25263           case DEFINER:
25264           case CURRENT_USER:
25265           case SERIALLY_REUSABLE:
25266           case RESTRICT_REFERENCES:
25267           case EXCEPTION_INIT:
25268           case AUTONOMOUS_TRANSACTION:
25269           case LANGUAGE:
25270           case ADD:
25271           case AGGREGATE:
25272           case ALL:
25273           case ALTER:
25274           case AND:
25275           case ANY:
25276           case ARRAY:
25277           case AS:
25278           case ASC:
25279           case AT:
25280           case ATTRIBUTE:
25281           case AUTHID:
25282           case AVG:
25283           case BETWEEN:
25284           case BINARY_INTEGER:
25285           case BODY:
25286           case BOOLEAN:
25287           case BULK:
25288           case BY:
25289           case BYTE:
25290           case CASCADE:
25291           case CASE:
25292           case CHAR:
25293           case CHAR_BASE:
25294           case CHECK:
25295           case CLOSE:
25296           case CLUSTER:
25297           case COALESCE:
25298           case COLLECT:
25299           case COLUMN:
25300           case COMMENT:
25301           case COMMIT:
25302           case COMPRESS:
25303           case CONNECT:
25304           case CONSTANT:
25305           case CONSTRUCTOR:
25306           case CONTINUE:
25307           case CONVERT:
25308           case CREATE:
25309           case CURRENT:
25310           case CURRVAL:
25311           case CURSOR:
25312           case DATA:
25313           case DATE:
25314           case DAY:
25315           case DECLARE:
25316           case DECIMAL:
25317           case _DEFAULT:
25318           case DELETE:
25319           case DESC:
25320           case DISABLE:
25321           case DISTINCT:
25322           case DO:
25323           case DROP:
25324           case EDITIONABLE:
25325           case ELEMENT:
25326           case ELSE:
25327           case ELSIF:
25328           case ENABLE:
25329           case ESCAPE:
25330           case EXCEPT:
25331           case EXCEPTION:
25332           case EXCEPTIONS:
25333           case EXCLUSIVE:
25334           case EXECUTE:
25335           case EXISTS:
25336           case EXIT:
25337           case EXTERNAL:
25338           case EXTENDS:
25339           case EXTRACT:
25340           case FALSE:
25341           case FETCH:
25342           case FINAL:
25343           case FLOAT:
25344           case FOR:
25345           case FORALL:
25346           case FORCE:
25347           case FROM:
25348           case FUNCTION:
25349           case GLOBAL:
25350           case GOTO:
25351           case GROUP:
25352           case HASH:
25353           case HAVING:
25354           case HEAP:
25355           case HOUR:
25356           case IF:
25357           case IMMEDIATE:
25358           case IN:
25359           case INDEX:
25360           case INDICES:
25361           case INDEXTYPE:
25362           case INDICATOR:
25363           case INSERT:
25364           case INSTANTIABLE:
25365           case INTEGER:
25366           case INTERFACE:
25367           case INTERSECT:
25368           case INTERVAL:
25369           case INTO:
25370           case INVALIDATE:
25371           case IS:
25372           case ISOLATION:
25373           case JAVA:
25374           case LEVEL:
25375           case LIKE:
25376           case LIMIT:
25377           case LIMITED:
25378           case LOCK:
25379           case LONG:
25380           case LOOP:
25381           case MAP:
25382           case MAX:
25383           case MEMBER:
25384           case MERGE:
25385           case MIN:
25386           case MINUS:
25387           case MINUTE:
25388           case MLSLABEL:
25389           case MODIFY:
25390           case MOD:
25391           case MODE:
25392           case MONTH:
25393           case NATURAL:
25394           case NATURALN:
25395           case NEW:
25396           case NEXTVAL:
25397           case NO:
25398           case NOCOPY:
25399           case NONEDITIONABLE:
25400           case NOT:
25401           case NOWAIT:
25402           case NULL:
25403           case NULLIF:
25404           case NUMBER:
25405           case BFILE_BASE:
25406           case BLOB_BASE:
25407           case CLOB_BASE:
25408           case DATE_BASE:
25409           case NUMBER_BASE:
25410           case OBJECT:
25411           case OCIROWID:
25412           case OF:
25413           case OID:
25414           case ON:
25415           case OPAQUE:
25416           case OPEN:
25417           case OPERATOR:
25418           case OPTION:
25419           case OR:
25420           case ORDER:
25421           case ORGANIZATION:
25422           case OTHERS:
25423           case OUT:
25424           case OVERRIDING:
25425           case PACKAGE:
25426           case PARTITION:
25427           case PCTFREE:
25428           case PLS_INTEGER:
25429           case POSITIVE:
25430           case POSITIVEN:
25431           case PRESERVE:
25432           case PRIOR:
25433           case PROMPT:
25434           case PRIVATE:
25435           case PROCEDURE:
25436           case PUBLIC:
25437           case RAISE:
25438           case RANGE:
25439           case RAW:
25440           case REAL:
25441           case RECORD:
25442           case REF:
25443           case RELEASE:
25444           case RELIES_ON:
25445           case RENAME:
25446           case RESULT:
25447           case RETURN:
25448           case RETURNING:
25449           case REVERSE:
25450           case ROLLBACK:
25451           case ROW:
25452           case ROWS:
25453           case ROWID:
25454           case ROWNUM:
25455           case ROWTYPE:
25456           case SAVE:
25457           case SAVEPOINT:
25458           case SECOND:
25459           case SELECT:
25460           case SELF:
25461           case SEPARATE:
25462           case SET:
25463           case SHARE:
25464           case SMALLINT:
25465           case SPACE:
25466           case SQL:
25467           case SQLCODE:
25468           case SQLERRM:
25469           case START:
25470           case STATIC:
25471           case STDDEV:
25472           case SUBTYPE:
25473           case SUBSTITUTABLE:
25474           case SUCCESSFUL:
25475           case SUM:
25476           case SYNONYM:
25477           case SYSDATE:
25478           case SYS_REFCURSOR:
25479           case TABLE:
25480           case TEMPORARY:
25481           case THEN:
25482           case TIME:
25483           case TIMESTAMP:
25484           case TIMEZONE_REGION:
25485           case TIMEZONE_ABBR:
25486           case TIMEZONE_MINUTE:
25487           case TIMEZONE_HOUR:
25488           case TO:
25489           case TRANSACTION:
25490           case TRIGGER:
25491           case TRUE:
25492           case TYPE:
25493           case UI:
25494           case UNDER:
25495           case USING:
25496           case WHILE:
25497           case YES:
25498           case SHOW:
25499           case A:
25500           case UPDATE:
25501           case VARCHAR:
25502           case VARCHAR2:
25503           case DOUBLE:
25504           case DEC:
25505           case PRECISION:
25506           case INT:
25507           case NUMERIC:
25508           case SIGNTYPE:
25509           case NCHAR:
25510           case NVARCHAR2:
25511           case STRING:
25512           case UROWID:
25513           case VARRAY:
25514           case VARYING:
25515           case BFILE:
25516           case BLOB:
25517           case CLOB:
25518           case NCLOB:
25519           case YEAR:
25520           case LOCAL:
25521           case WITH:
25522           case ZONE:
25523           case CHARACTER:
25524           case AFTER:
25525           case BEFORE:
25526           case OLD:
25527           case PARENT:
25528           case ANALYZE:
25529           case ASSOCIATE:
25530           case AUDIT:
25531           case COMPOUND:
25532           case DATABASE:
25533           case CALL:
25534           case DDL:
25535           case DISASSOCIATE:
25536           case EACH:
25537           case FOLLOWS:
25538           case LOGOFF:
25539           case LOGON:
25540           case NESTED:
25541           case NOAUDIT:
25542           case SCHEMA:
25543           case SERVERERROR:
25544           case SHUTDOWN:
25545           case STARTUP:
25546           case STATEMENT:
25547           case STATISTICS:
25548           case SUSPEND:
25549           case TRUNCATE:
25550           case WRAPPED:
25551           case LIBRARY:
25552           case NAME:
25553           case STRUCT:
25554           case CONTEXT:
25555           case PARAMETERS:
25556           case LENGTH:
25557           case TDO:
25558           case MAXLEN:
25559           case CHARSETID:
25560           case CHARSETFORM:
25561           case ACCEPT:
25562           case ACCESSIBLE:
25563           case COPY:
25564           case DEFINE:
25565           case DISCONNECT:
25566           case HOST:
25567           case PRINT:
25568           case QUIT:
25569           case REMARK:
25570           case UNDEFINE:
25571           case VARIABLE:
25572           case WHENEVER:
25573           case ATTACH:
25574           case CAST:
25575           case TREAT:
25576           case TRIM:
25577           case LEFT:
25578           case RIGHT:
25579           case BOTH:
25580           case EMPTY:
25581           case MULTISET:
25582           case SUBMULTISET:
25583           case LEADING:
25584           case TRAILING:
25585           case CHAR_CS:
25586           case NCHAR_CS:
25587           case DBTIMEZONE:
25588           case SESSIONTIMEZONE:
25589           case AUTHENTICATED:
25590           case LINK:
25591           case SHARED:
25592           case DIRECTORY:
25593           case USER:
25594           case IDENTIFIER:
25595           case QUOTED_LITERAL:
25596           case SQLDATA_CLASS:
25597           case CUSTOMDATUM_CLASS:
25598           case ORADATA_CLASS:
25599           case JAVA_INTERFACE_CLASS:
25600             AttributeDeclaration();
25601             break;
25602           default:
25603             jj_la1[376] = jj_gen;
25604             jj_consume_token(-1);
25605             throw new ParseException();
25606           }
25607         }
25608         label_90:
25609         while (true) {
25610           switch (jj_nt.kind) {
25611           case 6:
25612             ;
25613             break;
25614           default:
25615             jj_la1[377] = jj_gen;
25616             break label_90;
25617           }
25618           jj_consume_token(6);
25619           if (jj_2_71(2)) {
25620             TypeMethod();
25621           } else {
25622             switch (jj_nt.kind) {
25623             case REPLACE:
25624             case DEFINER:
25625             case CURRENT_USER:
25626             case SERIALLY_REUSABLE:
25627             case RESTRICT_REFERENCES:
25628             case EXCEPTION_INIT:
25629             case AUTONOMOUS_TRANSACTION:
25630             case LANGUAGE:
25631             case ADD:
25632             case AGGREGATE:
25633             case ALL:
25634             case ALTER:
25635             case AND:
25636             case ANY:
25637             case ARRAY:
25638             case AS:
25639             case ASC:
25640             case AT:
25641             case ATTRIBUTE:
25642             case AUTHID:
25643             case AVG:
25644             case BETWEEN:
25645             case BINARY_INTEGER:
25646             case BODY:
25647             case BOOLEAN:
25648             case BULK:
25649             case BY:
25650             case BYTE:
25651             case CASCADE:
25652             case CASE:
25653             case CHAR:
25654             case CHAR_BASE:
25655             case CHECK:
25656             case CLOSE:
25657             case CLUSTER:
25658             case COALESCE:
25659             case COLLECT:
25660             case COLUMN:
25661             case COMMENT:
25662             case COMMIT:
25663             case COMPRESS:
25664             case CONNECT:
25665             case CONSTANT:
25666             case CONSTRUCTOR:
25667             case CONTINUE:
25668             case CONVERT:
25669             case CREATE:
25670             case CURRENT:
25671             case CURRVAL:
25672             case CURSOR:
25673             case DATA:
25674             case DATE:
25675             case DAY:
25676             case DECLARE:
25677             case DECIMAL:
25678             case _DEFAULT:
25679             case DELETE:
25680             case DESC:
25681             case DISABLE:
25682             case DISTINCT:
25683             case DO:
25684             case DROP:
25685             case EDITIONABLE:
25686             case ELEMENT:
25687             case ELSE:
25688             case ELSIF:
25689             case ENABLE:
25690             case ESCAPE:
25691             case EXCEPT:
25692             case EXCEPTION:
25693             case EXCEPTIONS:
25694             case EXCLUSIVE:
25695             case EXECUTE:
25696             case EXISTS:
25697             case EXIT:
25698             case EXTERNAL:
25699             case EXTENDS:
25700             case EXTRACT:
25701             case FALSE:
25702             case FETCH:
25703             case FINAL:
25704             case FLOAT:
25705             case FOR:
25706             case FORALL:
25707             case FORCE:
25708             case FROM:
25709             case FUNCTION:
25710             case GLOBAL:
25711             case GOTO:
25712             case GROUP:
25713             case HASH:
25714             case HAVING:
25715             case HEAP:
25716             case HOUR:
25717             case IF:
25718             case IMMEDIATE:
25719             case IN:
25720             case INDEX:
25721             case INDICES:
25722             case INDEXTYPE:
25723             case INDICATOR:
25724             case INSERT:
25725             case INSTANTIABLE:
25726             case INTEGER:
25727             case INTERFACE:
25728             case INTERSECT:
25729             case INTERVAL:
25730             case INTO:
25731             case INVALIDATE:
25732             case IS:
25733             case ISOLATION:
25734             case JAVA:
25735             case LEVEL:
25736             case LIKE:
25737             case LIMIT:
25738             case LIMITED:
25739             case LOCK:
25740             case LONG:
25741             case LOOP:
25742             case MAP:
25743             case MAX:
25744             case MEMBER:
25745             case MERGE:
25746             case MIN:
25747             case MINUS:
25748             case MINUTE:
25749             case MLSLABEL:
25750             case MODIFY:
25751             case MOD:
25752             case MODE:
25753             case MONTH:
25754             case NATURAL:
25755             case NATURALN:
25756             case NEW:
25757             case NEXTVAL:
25758             case NO:
25759             case NOCOPY:
25760             case NONEDITIONABLE:
25761             case NOT:
25762             case NOWAIT:
25763             case NULL:
25764             case NULLIF:
25765             case NUMBER:
25766             case BFILE_BASE:
25767             case BLOB_BASE:
25768             case CLOB_BASE:
25769             case DATE_BASE:
25770             case NUMBER_BASE:
25771             case OBJECT:
25772             case OCIROWID:
25773             case OF:
25774             case OID:
25775             case ON:
25776             case OPAQUE:
25777             case OPEN:
25778             case OPERATOR:
25779             case OPTION:
25780             case OR:
25781             case ORDER:
25782             case ORGANIZATION:
25783             case OTHERS:
25784             case OUT:
25785             case OVERRIDING:
25786             case PACKAGE:
25787             case PARTITION:
25788             case PCTFREE:
25789             case PLS_INTEGER:
25790             case POSITIVE:
25791             case POSITIVEN:
25792             case PRESERVE:
25793             case PRIOR:
25794             case PROMPT:
25795             case PRIVATE:
25796             case PROCEDURE:
25797             case PUBLIC:
25798             case RAISE:
25799             case RANGE:
25800             case RAW:
25801             case REAL:
25802             case RECORD:
25803             case REF:
25804             case RELEASE:
25805             case RELIES_ON:
25806             case RENAME:
25807             case RESULT:
25808             case RETURN:
25809             case RETURNING:
25810             case REVERSE:
25811             case ROLLBACK:
25812             case ROW:
25813             case ROWS:
25814             case ROWID:
25815             case ROWNUM:
25816             case ROWTYPE:
25817             case SAVE:
25818             case SAVEPOINT:
25819             case SECOND:
25820             case SELECT:
25821             case SELF:
25822             case SEPARATE:
25823             case SET:
25824             case SHARE:
25825             case SMALLINT:
25826             case SPACE:
25827             case SQL:
25828             case SQLCODE:
25829             case SQLERRM:
25830             case START:
25831             case STATIC:
25832             case STDDEV:
25833             case SUBTYPE:
25834             case SUBSTITUTABLE:
25835             case SUCCESSFUL:
25836             case SUM:
25837             case SYNONYM:
25838             case SYSDATE:
25839             case SYS_REFCURSOR:
25840             case TABLE:
25841             case TEMPORARY:
25842             case THEN:
25843             case TIME:
25844             case TIMESTAMP:
25845             case TIMEZONE_REGION:
25846             case TIMEZONE_ABBR:
25847             case TIMEZONE_MINUTE:
25848             case TIMEZONE_HOUR:
25849             case TO:
25850             case TRANSACTION:
25851             case TRIGGER:
25852             case TRUE:
25853             case TYPE:
25854             case UI:
25855             case UNDER:
25856             case USING:
25857             case WHILE:
25858             case YES:
25859             case SHOW:
25860             case A:
25861             case UPDATE:
25862             case VARCHAR:
25863             case VARCHAR2:
25864             case DOUBLE:
25865             case DEC:
25866             case PRECISION:
25867             case INT:
25868             case NUMERIC:
25869             case SIGNTYPE:
25870             case NCHAR:
25871             case NVARCHAR2:
25872             case STRING:
25873             case UROWID:
25874             case VARRAY:
25875             case VARYING:
25876             case BFILE:
25877             case BLOB:
25878             case CLOB:
25879             case NCLOB:
25880             case YEAR:
25881             case LOCAL:
25882             case WITH:
25883             case ZONE:
25884             case CHARACTER:
25885             case AFTER:
25886             case BEFORE:
25887             case OLD:
25888             case PARENT:
25889             case ANALYZE:
25890             case ASSOCIATE:
25891             case AUDIT:
25892             case COMPOUND:
25893             case DATABASE:
25894             case CALL:
25895             case DDL:
25896             case DISASSOCIATE:
25897             case EACH:
25898             case FOLLOWS:
25899             case LOGOFF:
25900             case LOGON:
25901             case NESTED:
25902             case NOAUDIT:
25903             case SCHEMA:
25904             case SERVERERROR:
25905             case SHUTDOWN:
25906             case STARTUP:
25907             case STATEMENT:
25908             case STATISTICS:
25909             case SUSPEND:
25910             case TRUNCATE:
25911             case WRAPPED:
25912             case LIBRARY:
25913             case NAME:
25914             case STRUCT:
25915             case CONTEXT:
25916             case PARAMETERS:
25917             case LENGTH:
25918             case TDO:
25919             case MAXLEN:
25920             case CHARSETID:
25921             case CHARSETFORM:
25922             case ACCEPT:
25923             case ACCESSIBLE:
25924             case COPY:
25925             case DEFINE:
25926             case DISCONNECT:
25927             case HOST:
25928             case PRINT:
25929             case QUIT:
25930             case REMARK:
25931             case UNDEFINE:
25932             case VARIABLE:
25933             case WHENEVER:
25934             case ATTACH:
25935             case CAST:
25936             case TREAT:
25937             case TRIM:
25938             case LEFT:
25939             case RIGHT:
25940             case BOTH:
25941             case EMPTY:
25942             case MULTISET:
25943             case SUBMULTISET:
25944             case LEADING:
25945             case TRAILING:
25946             case CHAR_CS:
25947             case NCHAR_CS:
25948             case DBTIMEZONE:
25949             case SESSIONTIMEZONE:
25950             case AUTHENTICATED:
25951             case LINK:
25952             case SHARED:
25953             case DIRECTORY:
25954             case USER:
25955             case IDENTIFIER:
25956             case QUOTED_LITERAL:
25957             case SQLDATA_CLASS:
25958             case CUSTOMDATUM_CLASS:
25959             case ORADATA_CLASS:
25960             case JAVA_INTERFACE_CLASS:
25961               AttributeDeclaration();
25962               break;
25963             default:
25964               jj_la1[378] = jj_gen;
25965               jj_consume_token(-1);
25966               throw new ParseException();
25967             }
25968           }
25969         }
25970         jj_consume_token(7);
25971         break;
25972       default:
25973         jj_la1[379] = jj_gen;
25974         ;
25975       }
25976       label_91:
25977       while (true) {
25978         switch (jj_nt.kind) {
25979         case FINAL:
25980         case INSTANTIABLE:
25981         case NOT:
25982         case NULL:
25983           ;
25984           break;
25985         default:
25986           jj_la1[380] = jj_gen;
25987           break label_91;
25988         }
25989         switch (jj_nt.kind) {
25990         case NOT:
25991           jj_consume_token(NOT);
25992           break;
25993         default:
25994           jj_la1[381] = jj_gen;
25995           ;
25996         }
25997         switch (jj_nt.kind) {
25998         case FINAL:
25999           jj_consume_token(FINAL);
26000           break;
26001         case INSTANTIABLE:
26002           jj_consume_token(INSTANTIABLE);
26003           break;
26004         case NULL:
26005           jj_consume_token(NULL);
26006           break;
26007         default:
26008           jj_la1[382] = jj_gen;
26009           jj_consume_token(-1);
26010           throw new ParseException();
26011         }
26012       }
26013       switch (jj_nt.kind) {
26014       case CASCADE:
26015       case INVALIDATE:
26016         switch (jj_nt.kind) {
26017         case INVALIDATE:
26018           jj_consume_token(INVALIDATE);
26019           break;
26020         case CASCADE:
26021           jj_consume_token(CASCADE);
26022           label_92:
26023           while (true) {
26024             switch (jj_nt.kind) {
26025             case CONVERT:
26026             case INCLUDING:
26027             case NOT:
26028               ;
26029               break;
26030             default:
26031               jj_la1[383] = jj_gen;
26032               break label_92;
26033             }
26034             switch (jj_nt.kind) {
26035             case INCLUDING:
26036             case NOT:
26037               switch (jj_nt.kind) {
26038               case NOT:
26039                 jj_consume_token(NOT);
26040                 break;
26041               default:
26042                 jj_la1[384] = jj_gen;
26043                 ;
26044               }
26045               jj_consume_token(INCLUDING);
26046               jj_consume_token(TABLE);
26047               jj_consume_token(DATA);
26048               break;
26049             case CONVERT:
26050               jj_consume_token(CONVERT);
26051               jj_consume_token(TO);
26052               jj_consume_token(SUBSTITUTABLE);
26053               break;
26054             default:
26055               jj_la1[385] = jj_gen;
26056               jj_consume_token(-1);
26057               throw new ParseException();
26058             }
26059           }
26060           switch (jj_nt.kind) {
26061           case EXCEPTIONS:
26062           case FORCE:
26063             switch (jj_nt.kind) {
26064             case FORCE:
26065               jj_consume_token(FORCE);
26066               break;
26067             default:
26068               jj_la1[386] = jj_gen;
26069               ;
26070             }
26071             jj_consume_token(EXCEPTIONS);
26072             jj_consume_token(INTO);
26073             QualifiedName();
26074             break;
26075           default:
26076             jj_la1[387] = jj_gen;
26077             ;
26078           }
26079           break;
26080         default:
26081           jj_la1[388] = jj_gen;
26082           jj_consume_token(-1);
26083           throw new ParseException();
26084         }
26085         break;
26086       default:
26087         jj_la1[389] = jj_gen;
26088         ;
26089       }
26090         jjtree.closeNodeScope(jjtn000, true);
26091         jjtc000 = false;
26092         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
26093     } catch (Throwable jjte000) {
26094           if (jjtc000) {
26095             jjtree.clearNodeScope(jjtn000);
26096             jjtc000 = false;
26097           } else {
26098             jjtree.popNode();
26099           }
26100           if (jjte000 instanceof RuntimeException) {
26101             {if (true) throw (RuntimeException)jjte000;}
26102           }
26103           if (jjte000 instanceof ParseException) {
26104             {if (true) throw (ParseException)jjte000;}
26105           }
26106           {if (true) throw (Error)jjte000;}
26107     } finally {
26108           if (jjtc000) {
26109             jjtree.closeNodeScope(jjtn000, true);
26110           }
26111     }
26112     throw new Error("Missing return statement in function");
26113   }
26114 
26115 /*
26116 ASTTypeBody TypeBody()  :
26117 { Token name=null; }
26118 {
26119 	[<CREATE> [<OR> <REPLACE>]]
26120 
26121 	<TYPE> <BODY> (LOOKAHEAD(2) ID()".")? name=ID()
26122 
26123 	(
26124 	  (
26125 	    WrappedObject() 
26126 	  )
26127 	  |
26128 	  (
26129 	    (<IS> | <AS>)
26130 
26131 		    DeclarativeSection() //SRT 20110524 Allow PLDOc in Type Bodies 
26132 
26133 	    [ <BEGIN> (Statement())* (ExceptionHandler())? ] <END> [ID()] ";" 
26134 	  )
26135 	)
26136 }
26137 */
26138 
26139 
26140 /**
26141   * Method 
26142 **/
26143   final public ASTAttributeDeclaration AttributeDeclaration() throws ParseException {
26144  /*@bgen(jjtree) AttributeDeclaration */
26145  ASTAttributeDeclaration jjtn000 = new ASTAttributeDeclaration(this, JJTATTRIBUTEDECLARATION);
26146  boolean jjtc000 = true;
26147  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
26148     try {
26149       simpleNode = ID();
26150       Datatype();
26151         jjtree.closeNodeScope(jjtn000, true);
26152         jjtc000 = false;
26153         jjtn000.setImage(simpleNode.getImage()) ;   {if (true) return jjtn000 ;}
26154     } catch (Throwable jjte000) {
26155           if (jjtc000) {
26156             jjtree.clearNodeScope(jjtn000);
26157             jjtc000 = false;
26158           } else {
26159             jjtree.popNode();
26160           }
26161           if (jjte000 instanceof RuntimeException) {
26162             {if (true) throw (RuntimeException)jjte000;}
26163           }
26164           if (jjte000 instanceof ParseException) {
26165             {if (true) throw (ParseException)jjte000;}
26166           }
26167           {if (true) throw (Error)jjte000;}
26168     } finally {
26169           if (jjtc000) {
26170             jjtree.closeNodeScope(jjtn000, true);
26171           }
26172     }
26173     throw new Error("Missing return statement in function");
26174   }
26175 
26176   final public ASTAttribute Attribute() throws ParseException {
26177  /*@bgen(jjtree) Attribute */
26178  ASTAttribute jjtn000 = new ASTAttribute(this, JJTATTRIBUTE);
26179  boolean jjtc000 = true;
26180  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
26181     try {
26182       simpleNode = ID();
26183         jjtree.closeNodeScope(jjtn000, true);
26184         jjtc000 = false;
26185         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
26186     } catch (Throwable jjte000) {
26187         if (jjtc000) {
26188           jjtree.clearNodeScope(jjtn000);
26189           jjtc000 = false;
26190         } else {
26191           jjtree.popNode();
26192         }
26193         if (jjte000 instanceof RuntimeException) {
26194           {if (true) throw (RuntimeException)jjte000;}
26195         }
26196         if (jjte000 instanceof ParseException) {
26197           {if (true) throw (ParseException)jjte000;}
26198         }
26199         {if (true) throw (Error)jjte000;}
26200     } finally {
26201         if (jjtc000) {
26202           jjtree.closeNodeScope(jjtn000, true);
26203         }
26204     }
26205     throw new Error("Missing return statement in function");
26206   }
26207 
26208 /*
26209  This was quick cut from PRAGMA
26210 */
26211   final public ASTPragmaClause PragmaClause() throws ParseException {
26212  /*@bgen(jjtree) PragmaClause */
26213   ASTPragmaClause jjtn000 = new ASTPragmaClause(this, JJTPRAGMACLAUSE);
26214   boolean jjtc000 = true;
26215   jjtree.openNodeScope(jjtn000);
26216     try {
26217       jj_consume_token(PRAGMA);
26218       switch (jj_nt.kind) {
26219       case SERIALLY_REUSABLE:
26220         jj_consume_token(SERIALLY_REUSABLE);
26221         break;
26222       case AUTONOMOUS_TRANSACTION:
26223         jj_consume_token(AUTONOMOUS_TRANSACTION);
26224         break;
26225       case RESTRICT_REFERENCES:
26226         jj_consume_token(RESTRICT_REFERENCES);
26227         jj_consume_token(5);
26228         ID();
26229         label_93:
26230         while (true) {
26231           jj_consume_token(6);
26232           switch (jj_nt.kind) {
26233           case REPLACE:
26234           case DEFINER:
26235           case CURRENT_USER:
26236           case SERIALLY_REUSABLE:
26237           case RESTRICT_REFERENCES:
26238           case EXCEPTION_INIT:
26239           case AUTONOMOUS_TRANSACTION:
26240           case LANGUAGE:
26241           case ADD:
26242           case AGGREGATE:
26243           case ALL:
26244           case ALTER:
26245           case AND:
26246           case ANY:
26247           case ARRAY:
26248           case AS:
26249           case ASC:
26250           case AT:
26251           case ATTRIBUTE:
26252           case AUTHID:
26253           case AVG:
26254           case BETWEEN:
26255           case BINARY_INTEGER:
26256           case BODY:
26257           case BOOLEAN:
26258           case BULK:
26259           case BY:
26260           case BYTE:
26261           case CASCADE:
26262           case CASE:
26263           case CHAR:
26264           case CHAR_BASE:
26265           case CHECK:
26266           case CLOSE:
26267           case CLUSTER:
26268           case COALESCE:
26269           case COLLECT:
26270           case COLUMN:
26271           case COMMENT:
26272           case COMMIT:
26273           case COMPRESS:
26274           case CONNECT:
26275           case CONSTANT:
26276           case CONSTRUCTOR:
26277           case CONTINUE:
26278           case CONVERT:
26279           case CREATE:
26280           case CURRENT:
26281           case CURRVAL:
26282           case CURSOR:
26283           case DATA:
26284           case DATE:
26285           case DAY:
26286           case DECLARE:
26287           case DECIMAL:
26288           case _DEFAULT:
26289           case DELETE:
26290           case DESC:
26291           case DISABLE:
26292           case DISTINCT:
26293           case DO:
26294           case DROP:
26295           case EDITIONABLE:
26296           case ELEMENT:
26297           case ELSE:
26298           case ELSIF:
26299           case ENABLE:
26300           case ESCAPE:
26301           case EXCEPT:
26302           case EXCEPTION:
26303           case EXCEPTIONS:
26304           case EXCLUSIVE:
26305           case EXECUTE:
26306           case EXISTS:
26307           case EXIT:
26308           case EXTERNAL:
26309           case EXTENDS:
26310           case EXTRACT:
26311           case FALSE:
26312           case FETCH:
26313           case FINAL:
26314           case FLOAT:
26315           case FOR:
26316           case FORALL:
26317           case FORCE:
26318           case FROM:
26319           case FUNCTION:
26320           case GLOBAL:
26321           case GOTO:
26322           case GROUP:
26323           case HASH:
26324           case HAVING:
26325           case HEAP:
26326           case HOUR:
26327           case IF:
26328           case IMMEDIATE:
26329           case IN:
26330           case INDEX:
26331           case INDICES:
26332           case INDEXTYPE:
26333           case INDICATOR:
26334           case INSERT:
26335           case INSTANTIABLE:
26336           case INTEGER:
26337           case INTERFACE:
26338           case INTERSECT:
26339           case INTERVAL:
26340           case INTO:
26341           case INVALIDATE:
26342           case IS:
26343           case ISOLATION:
26344           case JAVA:
26345           case LEVEL:
26346           case LIKE:
26347           case LIMIT:
26348           case LIMITED:
26349           case LOCK:
26350           case LONG:
26351           case LOOP:
26352           case MAP:
26353           case MAX:
26354           case MEMBER:
26355           case MERGE:
26356           case MIN:
26357           case MINUS:
26358           case MINUTE:
26359           case MLSLABEL:
26360           case MODIFY:
26361           case MOD:
26362           case MODE:
26363           case MONTH:
26364           case NATURAL:
26365           case NATURALN:
26366           case NEW:
26367           case NEXTVAL:
26368           case NO:
26369           case NOCOPY:
26370           case NONEDITIONABLE:
26371           case NOT:
26372           case NOWAIT:
26373           case NULL:
26374           case NULLIF:
26375           case NUMBER:
26376           case BFILE_BASE:
26377           case BLOB_BASE:
26378           case CLOB_BASE:
26379           case DATE_BASE:
26380           case NUMBER_BASE:
26381           case OBJECT:
26382           case OCIROWID:
26383           case OF:
26384           case OID:
26385           case ON:
26386           case OPAQUE:
26387           case OPEN:
26388           case OPERATOR:
26389           case OPTION:
26390           case OR:
26391           case ORDER:
26392           case ORGANIZATION:
26393           case OTHERS:
26394           case OUT:
26395           case OVERRIDING:
26396           case PACKAGE:
26397           case PARTITION:
26398           case PCTFREE:
26399           case PLS_INTEGER:
26400           case POSITIVE:
26401           case POSITIVEN:
26402           case PRESERVE:
26403           case PRIOR:
26404           case PROMPT:
26405           case PRIVATE:
26406           case PROCEDURE:
26407           case PUBLIC:
26408           case RAISE:
26409           case RANGE:
26410           case RAW:
26411           case REAL:
26412           case RECORD:
26413           case REF:
26414           case RELEASE:
26415           case RELIES_ON:
26416           case RENAME:
26417           case RESULT:
26418           case RETURN:
26419           case RETURNING:
26420           case REVERSE:
26421           case ROLLBACK:
26422           case ROW:
26423           case ROWS:
26424           case ROWID:
26425           case ROWNUM:
26426           case ROWTYPE:
26427           case SAVE:
26428           case SAVEPOINT:
26429           case SECOND:
26430           case SELECT:
26431           case SELF:
26432           case SEPARATE:
26433           case SET:
26434           case SHARE:
26435           case SMALLINT:
26436           case SPACE:
26437           case SQL:
26438           case SQLCODE:
26439           case SQLERRM:
26440           case START:
26441           case STATIC:
26442           case STDDEV:
26443           case SUBTYPE:
26444           case SUBSTITUTABLE:
26445           case SUCCESSFUL:
26446           case SUM:
26447           case SYNONYM:
26448           case SYSDATE:
26449           case SYS_REFCURSOR:
26450           case TABLE:
26451           case TEMPORARY:
26452           case THEN:
26453           case TIME:
26454           case TIMESTAMP:
26455           case TIMEZONE_REGION:
26456           case TIMEZONE_ABBR:
26457           case TIMEZONE_MINUTE:
26458           case TIMEZONE_HOUR:
26459           case TO:
26460           case TRANSACTION:
26461           case TRIGGER:
26462           case TRUE:
26463           case TYPE:
26464           case UI:
26465           case UNDER:
26466           case USING:
26467           case WHILE:
26468           case YES:
26469           case SHOW:
26470           case A:
26471           case UPDATE:
26472           case VARCHAR:
26473           case VARCHAR2:
26474           case DOUBLE:
26475           case DEC:
26476           case PRECISION:
26477           case INT:
26478           case NUMERIC:
26479           case SIGNTYPE:
26480           case NCHAR:
26481           case NVARCHAR2:
26482           case STRING:
26483           case UROWID:
26484           case VARRAY:
26485           case VARYING:
26486           case BFILE:
26487           case BLOB:
26488           case CLOB:
26489           case NCLOB:
26490           case YEAR:
26491           case LOCAL:
26492           case WITH:
26493           case ZONE:
26494           case CHARACTER:
26495           case AFTER:
26496           case BEFORE:
26497           case OLD:
26498           case PARENT:
26499           case ANALYZE:
26500           case ASSOCIATE:
26501           case AUDIT:
26502           case COMPOUND:
26503           case DATABASE:
26504           case CALL:
26505           case DDL:
26506           case DISASSOCIATE:
26507           case EACH:
26508           case FOLLOWS:
26509           case LOGOFF:
26510           case LOGON:
26511           case NESTED:
26512           case NOAUDIT:
26513           case SCHEMA:
26514           case SERVERERROR:
26515           case SHUTDOWN:
26516           case STARTUP:
26517           case STATEMENT:
26518           case STATISTICS:
26519           case SUSPEND:
26520           case TRUNCATE:
26521           case WRAPPED:
26522           case LIBRARY:
26523           case NAME:
26524           case STRUCT:
26525           case CONTEXT:
26526           case PARAMETERS:
26527           case LENGTH:
26528           case TDO:
26529           case MAXLEN:
26530           case CHARSETID:
26531           case CHARSETFORM:
26532           case ACCEPT:
26533           case ACCESSIBLE:
26534           case COPY:
26535           case DEFINE:
26536           case DISCONNECT:
26537           case HOST:
26538           case PRINT:
26539           case QUIT:
26540           case REMARK:
26541           case UNDEFINE:
26542           case VARIABLE:
26543           case WHENEVER:
26544           case ATTACH:
26545           case CAST:
26546           case TREAT:
26547           case TRIM:
26548           case LEFT:
26549           case RIGHT:
26550           case BOTH:
26551           case EMPTY:
26552           case MULTISET:
26553           case SUBMULTISET:
26554           case LEADING:
26555           case TRAILING:
26556           case CHAR_CS:
26557           case NCHAR_CS:
26558           case DBTIMEZONE:
26559           case SESSIONTIMEZONE:
26560           case AUTHENTICATED:
26561           case LINK:
26562           case SHARED:
26563           case DIRECTORY:
26564           case USER:
26565           case IDENTIFIER:
26566           case QUOTED_LITERAL:
26567           case SQLDATA_CLASS:
26568           case CUSTOMDATUM_CLASS:
26569           case ORADATA_CLASS:
26570           case JAVA_INTERFACE_CLASS:
26571             ID();
26572             break;
26573           case STRING_LITERAL:
26574             StringLiteral();
26575             break;
26576           default:
26577             jj_la1[390] = jj_gen;
26578             jj_consume_token(-1);
26579             throw new ParseException();
26580           }
26581           switch (jj_nt.kind) {
26582           case 6:
26583             ;
26584             break;
26585           default:
26586             jj_la1[391] = jj_gen;
26587             break label_93;
26588           }
26589         }
26590         jj_consume_token(7);
26591         break;
26592       case EXCEPTION_INIT:
26593         jj_consume_token(EXCEPTION_INIT);
26594         jj_consume_token(5);
26595         jj_consume_token(IDENTIFIER);
26596         jj_consume_token(6);
26597         switch (jj_nt.kind) {
26598         case 16:
26599         case 17:
26600           switch (jj_nt.kind) {
26601           case 16:
26602             jj_consume_token(16);
26603             break;
26604           case 17:
26605             jj_consume_token(17);
26606             break;
26607           default:
26608             jj_la1[392] = jj_gen;
26609             jj_consume_token(-1);
26610             throw new ParseException();
26611           }
26612           break;
26613         default:
26614           jj_la1[393] = jj_gen;
26615           ;
26616         }
26617         NumericLiteral();
26618         jj_consume_token(7);
26619         break;
26620       case INTERFACE:
26621         jj_consume_token(INTERFACE);
26622         jj_consume_token(5);
26623         jj_consume_token(IDENTIFIER);
26624         jj_consume_token(6);
26625         jj_consume_token(IDENTIFIER);
26626         jj_consume_token(6);
26627         NumericLiteral();
26628         jj_consume_token(7);
26629         break;
26630       default:
26631         jj_la1[394] = jj_gen;
26632         jj_consume_token(-1);
26633         throw new ParseException();
26634       }
26635         jjtree.closeNodeScope(jjtn000, true);
26636         jjtc000 = false;
26637         {if (true) return jjtn000 ;}
26638     } catch (Throwable jjte000) {
26639           if (jjtc000) {
26640             jjtree.clearNodeScope(jjtn000);
26641             jjtc000 = false;
26642           } else {
26643             jjtree.popNode();
26644           }
26645           if (jjte000 instanceof RuntimeException) {
26646             {if (true) throw (RuntimeException)jjte000;}
26647           }
26648           if (jjte000 instanceof ParseException) {
26649             {if (true) throw (ParseException)jjte000;}
26650           }
26651           {if (true) throw (Error)jjte000;}
26652     } finally {
26653           if (jjtc000) {
26654             jjtree.closeNodeScope(jjtn000, true);
26655           }
26656     }
26657     throw new Error("Missing return statement in function");
26658   }
26659 
26660 /** 
26661  * Trigger
26662  * Triggers are always outside of a package.
26663  *
26664  *  2006-05-17 - Matthias Hendler - added 
26665  */
26666 
26667 /*
26668   11g Trigger Syntax 
26669 
26670  create_trigger : 
26671  CREATE [OR REPLACE] TRIGGER [schema.]trigger 
26672 ( simple_dml_trigger | compound_dml_trigger | non_dml_trigger )
26673 [ FOLLOWS ( [schema.]trigger) ( , [schema.]trigger)*  ]
26674 [ ENABLE  | DISABLE ]
26675 ( WHEN ( trigger_condition ) 
26676 trigger_body
26677 
26678 
26679 simple_dml_trigger :
26680 (BEFORE |AFTER | INSTEAD OF)
26681 dml_event_clause 
26682 [ referencing_clause ]
26683 [ FOR EACH ROW ]
26684 
26685 
26686 
26687 compound_dml_trigger :
26688 FOR dml_event_clause 
26689 [ referencing_clause ]
26690 
26691 
26692 non_dml_trigger :
26693 (BEFORE> |<AFTER> ) 
26694 (DDLEvent | database_event) ( OR (DDLEvent | database_event))*
26695 ON
26696 (DATABASE | [schema.]SCHEMA
26697 
26698 
26699 
26700 trigger_body :
26701 (plsql_block | compound_trigger_block | CALL routine_clause)
26702 
26703 
26704 
26705 dml_event_clause:
26706 ( DELETE | INSERT | UPDATE [ OF column (, column ) ] )
26707 ON ( (schema.table | NESTED TABLE nested_table_column OF [schema.]view )
26708 
26709 referencing_clause:
26710 REFERENCING 
26711 (OLD AS old_alias | NEW AS new_alias | PARENT AS parent_alias )*  
26712 
26713 
26714 compound_trigger_block :
26715 COMPOUND TRIGGER 
26716 declare_section 
26717 (timing_point_section)+  
26718 END [trigger_name] ;
26719 
26720 timing_point_section:
26721 (
26722 BEFORE STATEMENT IS tps_body END BEFORE STATEMENT 
26723 |BEFORE EACH ROW IS tps_body END BEFORE EACH ROW 
26724 |AFTER STATEMENT IS tps_body END AFTER STATEMENT 
26725 |AFTER EACH ROW IS tps_body END AFTER EACH ROW 
26726 )
26727 
26728 
26729 tps_body:
26730 (statement)+
26731 (EXCEPTION exception_handler )*
26732 
26733 */
26734   final public ASTTriggerUnit TriggerUnit() throws ParseException {
26735  /*@bgen(jjtree) TriggerUnit */
26736  ASTTriggerUnit jjtn000 = new ASTTriggerUnit(this, JJTTRIGGERUNIT);
26737  boolean jjtc000 = true;
26738  jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
26739     try {
26740       switch (jj_nt.kind) {
26741       case CREATE:
26742         jj_consume_token(CREATE);
26743         switch (jj_nt.kind) {
26744         case OR:
26745           jj_consume_token(OR);
26746           jj_consume_token(REPLACE);
26747           break;
26748         default:
26749           jj_la1[395] = jj_gen;
26750           ;
26751         }
26752         switch (jj_nt.kind) {
26753         case EDITIONABLE:
26754         case NONEDITIONABLE:
26755           switch (jj_nt.kind) {
26756           case EDITIONABLE:
26757             jj_consume_token(EDITIONABLE);
26758             break;
26759           case NONEDITIONABLE:
26760             jj_consume_token(NONEDITIONABLE);
26761             break;
26762           default:
26763             jj_la1[396] = jj_gen;
26764             jj_consume_token(-1);
26765             throw new ParseException();
26766           }
26767           break;
26768         default:
26769           jj_la1[397] = jj_gen;
26770           ;
26771         }
26772         break;
26773       default:
26774         jj_la1[398] = jj_gen;
26775         ;
26776       }
26777       jj_consume_token(TRIGGER);
26778       simpleNode = ObjectNameDeclaration();
26779       switch (jj_nt.kind) {
26780       case BEFORE:
26781         jj_consume_token(BEFORE);
26782         break;
26783       case AFTER:
26784         jj_consume_token(AFTER);
26785         break;
26786       case INSTEADOF:
26787         jj_consume_token(INSTEADOF);
26788         break;
26789       case FOR:
26790         jj_consume_token(FOR);
26791         break;
26792       default:
26793         jj_la1[399] = jj_gen;
26794         jj_consume_token(-1);
26795         throw new ParseException();
26796       }
26797       switch (jj_nt.kind) {
26798       case DELETE:
26799       case INSERT:
26800       case UPDATE:
26801         switch (jj_nt.kind) {
26802         case DELETE:
26803           jj_consume_token(DELETE);
26804           break;
26805         case INSERT:
26806           jj_consume_token(INSERT);
26807           break;
26808         case UPDATE:
26809           jj_consume_token(UPDATE);
26810           break;
26811         default:
26812           jj_la1[400] = jj_gen;
26813           jj_consume_token(-1);
26814           throw new ParseException();
26815         }
26816         if (jj_2_72(6)) {
26817           jj_consume_token(OF);
26818           ID();
26819           label_94:
26820           while (true) {
26821             switch (jj_nt.kind) {
26822             case 6:
26823               ;
26824               break;
26825             default:
26826               jj_la1[401] = jj_gen;
26827               break label_94;
26828             }
26829             jj_consume_token(6);
26830             ID();
26831           }
26832         } else {
26833           ;
26834         }
26835         break;
26836       case ALTER:
26837       case COMMENT:
26838       case CREATE:
26839       case DROP:
26840       case GRANT:
26841       case RENAME:
26842       case REVOKE:
26843       case ANALYZE:
26844       case ASSOCIATE:
26845       case AUDIT:
26846       case DDL:
26847       case DISASSOCIATE:
26848       case LOGOFF:
26849       case LOGON:
26850       case NOAUDIT:
26851       case SERVERERROR:
26852       case SHUTDOWN:
26853       case STARTUP:
26854       case SUSPEND:
26855       case TRUNCATE:
26856         NonDMLEvent();
26857         break;
26858       default:
26859         jj_la1[402] = jj_gen;
26860         jj_consume_token(-1);
26861         throw new ParseException();
26862       }
26863       label_95:
26864       while (true) {
26865         switch (jj_nt.kind) {
26866         case OR:
26867           ;
26868           break;
26869         default:
26870           jj_la1[403] = jj_gen;
26871           break label_95;
26872         }
26873         jj_consume_token(OR);
26874         switch (jj_nt.kind) {
26875         case DELETE:
26876         case INSERT:
26877         case UPDATE:
26878           switch (jj_nt.kind) {
26879           case DELETE:
26880             jj_consume_token(DELETE);
26881             break;
26882           case INSERT:
26883             jj_consume_token(INSERT);
26884             break;
26885           case UPDATE:
26886             jj_consume_token(UPDATE);
26887             break;
26888           default:
26889             jj_la1[404] = jj_gen;
26890             jj_consume_token(-1);
26891             throw new ParseException();
26892           }
26893           if (jj_2_73(6)) {
26894             jj_consume_token(OF);
26895             ID();
26896             label_96:
26897             while (true) {
26898               switch (jj_nt.kind) {
26899               case 6:
26900                 ;
26901                 break;
26902               default:
26903                 jj_la1[405] = jj_gen;
26904                 break label_96;
26905               }
26906               jj_consume_token(6);
26907               ID();
26908             }
26909           } else {
26910             ;
26911           }
26912           break;
26913         case ALTER:
26914         case COMMENT:
26915         case CREATE:
26916         case DROP:
26917         case GRANT:
26918         case RENAME:
26919         case REVOKE:
26920         case ANALYZE:
26921         case ASSOCIATE:
26922         case AUDIT:
26923         case DDL:
26924         case DISASSOCIATE:
26925         case LOGOFF:
26926         case LOGON:
26927         case NOAUDIT:
26928         case SERVERERROR:
26929         case SHUTDOWN:
26930         case STARTUP:
26931         case SUSPEND:
26932         case TRUNCATE:
26933           NonDMLEvent();
26934           break;
26935         default:
26936           jj_la1[406] = jj_gen;
26937           jj_consume_token(-1);
26938           throw new ParseException();
26939         }
26940       }
26941       jj_consume_token(ON);
26942       switch (jj_nt.kind) {
26943       case DATABASE:
26944         jj_consume_token(DATABASE);
26945         break;
26946       default:
26947         jj_la1[407] = jj_gen;
26948         if (jj_2_76(2)) {
26949           jj_consume_token(NESTED);
26950           jj_consume_token(TABLE);
26951           ID();
26952           jj_consume_token(OF);
26953           if (jj_2_74(2)) {
26954             ID();
26955             jj_consume_token(3);
26956           } else {
26957             ;
26958           }
26959           ID();
26960         } else {
26961           switch (jj_nt.kind) {
26962           case REPLACE:
26963           case DEFINER:
26964           case CURRENT_USER:
26965           case SERIALLY_REUSABLE:
26966           case RESTRICT_REFERENCES:
26967           case EXCEPTION_INIT:
26968           case AUTONOMOUS_TRANSACTION:
26969           case LANGUAGE:
26970           case ADD:
26971           case AGGREGATE:
26972           case ALL:
26973           case ALTER:
26974           case AND:
26975           case ANY:
26976           case ARRAY:
26977           case AS:
26978           case ASC:
26979           case AT:
26980           case ATTRIBUTE:
26981           case AUTHID:
26982           case AVG:
26983           case BETWEEN:
26984           case BINARY_INTEGER:
26985           case BODY:
26986           case BOOLEAN:
26987           case BULK:
26988           case BY:
26989           case BYTE:
26990           case CASCADE:
26991           case CASE:
26992           case CHAR:
26993           case CHAR_BASE:
26994           case CHECK:
26995           case CLOSE:
26996           case CLUSTER:
26997           case COALESCE:
26998           case COLLECT:
26999           case COLUMN:
27000           case COMMENT:
27001           case COMMIT:
27002           case COMPRESS:
27003           case CONNECT:
27004           case CONSTANT:
27005           case CONSTRUCTOR:
27006           case CONTINUE:
27007           case CONVERT:
27008           case CREATE:
27009           case CURRENT:
27010           case CURRVAL:
27011           case CURSOR:
27012           case DATA:
27013           case DATE:
27014           case DAY:
27015           case DECLARE:
27016           case DECIMAL:
27017           case _DEFAULT:
27018           case DELETE:
27019           case DESC:
27020           case DISABLE:
27021           case DISTINCT:
27022           case DO:
27023           case DROP:
27024           case EDITIONABLE:
27025           case ELEMENT:
27026           case ELSE:
27027           case ELSIF:
27028           case ENABLE:
27029           case ESCAPE:
27030           case EXCEPT:
27031           case EXCEPTION:
27032           case EXCEPTIONS:
27033           case EXCLUSIVE:
27034           case EXECUTE:
27035           case EXISTS:
27036           case EXIT:
27037           case EXTERNAL:
27038           case EXTENDS:
27039           case EXTRACT:
27040           case FALSE:
27041           case FETCH:
27042           case FINAL:
27043           case FLOAT:
27044           case FOR:
27045           case FORALL:
27046           case FORCE:
27047           case FROM:
27048           case FUNCTION:
27049           case GLOBAL:
27050           case GOTO:
27051           case GROUP:
27052           case HASH:
27053           case HAVING:
27054           case HEAP:
27055           case HOUR:
27056           case IF:
27057           case IMMEDIATE:
27058           case IN:
27059           case INDEX:
27060           case INDICES:
27061           case INDEXTYPE:
27062           case INDICATOR:
27063           case INSERT:
27064           case INSTANTIABLE:
27065           case INTEGER:
27066           case INTERFACE:
27067           case INTERSECT:
27068           case INTERVAL:
27069           case INTO:
27070           case INVALIDATE:
27071           case IS:
27072           case ISOLATION:
27073           case JAVA:
27074           case LEVEL:
27075           case LIKE:
27076           case LIMIT:
27077           case LIMITED:
27078           case LOCK:
27079           case LONG:
27080           case LOOP:
27081           case MAP:
27082           case MAX:
27083           case MEMBER:
27084           case MERGE:
27085           case MIN:
27086           case MINUS:
27087           case MINUTE:
27088           case MLSLABEL:
27089           case MODIFY:
27090           case MOD:
27091           case MODE:
27092           case MONTH:
27093           case NATURAL:
27094           case NATURALN:
27095           case NEW:
27096           case NEXTVAL:
27097           case NO:
27098           case NOCOPY:
27099           case NONEDITIONABLE:
27100           case NOT:
27101           case NOWAIT:
27102           case NULL:
27103           case NULLIF:
27104           case NUMBER:
27105           case BFILE_BASE:
27106           case BLOB_BASE:
27107           case CLOB_BASE:
27108           case DATE_BASE:
27109           case NUMBER_BASE:
27110           case OBJECT:
27111           case OCIROWID:
27112           case OF:
27113           case OID:
27114           case ON:
27115           case OPAQUE:
27116           case OPEN:
27117           case OPERATOR:
27118           case OPTION:
27119           case OR:
27120           case ORDER:
27121           case ORGANIZATION:
27122           case OTHERS:
27123           case OUT:
27124           case OVERRIDING:
27125           case PACKAGE:
27126           case PARTITION:
27127           case PCTFREE:
27128           case PLS_INTEGER:
27129           case POSITIVE:
27130           case POSITIVEN:
27131           case PRESERVE:
27132           case PRIOR:
27133           case PROMPT:
27134           case PRIVATE:
27135           case PROCEDURE:
27136           case PUBLIC:
27137           case RAISE:
27138           case RANGE:
27139           case RAW:
27140           case REAL:
27141           case RECORD:
27142           case REF:
27143           case RELEASE:
27144           case RELIES_ON:
27145           case RENAME:
27146           case RESULT:
27147           case RETURN:
27148           case RETURNING:
27149           case REVERSE:
27150           case ROLLBACK:
27151           case ROW:
27152           case ROWS:
27153           case ROWID:
27154           case ROWNUM:
27155           case ROWTYPE:
27156           case SAVE:
27157           case SAVEPOINT:
27158           case SECOND:
27159           case SELECT:
27160           case SELF:
27161           case SEPARATE:
27162           case SET:
27163           case SHARE:
27164           case SMALLINT:
27165           case SPACE:
27166           case SQL:
27167           case SQLCODE:
27168           case SQLERRM:
27169           case START:
27170           case STATIC:
27171           case STDDEV:
27172           case SUBTYPE:
27173           case SUBSTITUTABLE:
27174           case SUCCESSFUL:
27175           case SUM:
27176           case SYNONYM:
27177           case SYSDATE:
27178           case SYS_REFCURSOR:
27179           case TABLE:
27180           case TEMPORARY:
27181           case THEN:
27182           case TIME:
27183           case TIMESTAMP:
27184           case TIMEZONE_REGION:
27185           case TIMEZONE_ABBR:
27186           case TIMEZONE_MINUTE:
27187           case TIMEZONE_HOUR:
27188           case TO:
27189           case TRANSACTION:
27190           case TRIGGER:
27191           case TRUE:
27192           case TYPE:
27193           case UI:
27194           case UNDER:
27195           case USING:
27196           case WHILE:
27197           case YES:
27198           case SHOW:
27199           case A:
27200           case UPDATE:
27201           case VARCHAR:
27202           case VARCHAR2:
27203           case DOUBLE:
27204           case DEC:
27205           case PRECISION:
27206           case INT:
27207           case NUMERIC:
27208           case SIGNTYPE:
27209           case NCHAR:
27210           case NVARCHAR2:
27211           case STRING:
27212           case UROWID:
27213           case VARRAY:
27214           case VARYING:
27215           case BFILE:
27216           case BLOB:
27217           case CLOB:
27218           case NCLOB:
27219           case YEAR:
27220           case LOCAL:
27221           case WITH:
27222           case ZONE:
27223           case CHARACTER:
27224           case AFTER:
27225           case BEFORE:
27226           case OLD:
27227           case PARENT:
27228           case ANALYZE:
27229           case ASSOCIATE:
27230           case AUDIT:
27231           case COMPOUND:
27232           case DATABASE:
27233           case CALL:
27234           case DDL:
27235           case DISASSOCIATE:
27236           case EACH:
27237           case FOLLOWS:
27238           case LOGOFF:
27239           case LOGON:
27240           case NESTED:
27241           case NOAUDIT:
27242           case SCHEMA:
27243           case SERVERERROR:
27244           case SHUTDOWN:
27245           case STARTUP:
27246           case STATEMENT:
27247           case STATISTICS:
27248           case SUSPEND:
27249           case TRUNCATE:
27250           case WRAPPED:
27251           case LIBRARY:
27252           case NAME:
27253           case STRUCT:
27254           case CONTEXT:
27255           case PARAMETERS:
27256           case LENGTH:
27257           case TDO:
27258           case MAXLEN:
27259           case CHARSETID:
27260           case CHARSETFORM:
27261           case ACCEPT:
27262           case ACCESSIBLE:
27263           case COPY:
27264           case DEFINE:
27265           case DISCONNECT:
27266           case HOST:
27267           case PRINT:
27268           case QUIT:
27269           case REMARK:
27270           case UNDEFINE:
27271           case VARIABLE:
27272           case WHENEVER:
27273           case ATTACH:
27274           case CAST:
27275           case TREAT:
27276           case TRIM:
27277           case LEFT:
27278           case RIGHT:
27279           case BOTH:
27280           case EMPTY:
27281           case MULTISET:
27282           case SUBMULTISET:
27283           case LEADING:
27284           case TRAILING:
27285           case CHAR_CS:
27286           case NCHAR_CS:
27287           case DBTIMEZONE:
27288           case SESSIONTIMEZONE:
27289           case AUTHENTICATED:
27290           case LINK:
27291           case SHARED:
27292           case DIRECTORY:
27293           case USER:
27294           case IDENTIFIER:
27295           case QUOTED_LITERAL:
27296           case SQLDATA_CLASS:
27297           case CUSTOMDATUM_CLASS:
27298           case ORADATA_CLASS:
27299           case JAVA_INTERFACE_CLASS:
27300             if (jj_2_75(2)) {
27301               ID();
27302               jj_consume_token(3);
27303             } else {
27304               ;
27305             }
27306             ID();
27307             break;
27308           default:
27309             jj_la1[408] = jj_gen;
27310             jj_consume_token(-1);
27311             throw new ParseException();
27312           }
27313         }
27314       }
27315       switch (jj_nt.kind) {
27316       case REFERENCING:
27317         jj_consume_token(REFERENCING);
27318         label_97:
27319         while (true) {
27320           switch (jj_nt.kind) {
27321           case NEW:
27322           case OLD:
27323           case PARENT:
27324             ;
27325             break;
27326           default:
27327             jj_la1[409] = jj_gen;
27328             break label_97;
27329           }
27330           switch (jj_nt.kind) {
27331           case OLD:
27332             jj_consume_token(OLD);
27333             break;
27334           case NEW:
27335             jj_consume_token(NEW);
27336             break;
27337           case PARENT:
27338             jj_consume_token(PARENT);
27339             break;
27340           default:
27341             jj_la1[410] = jj_gen;
27342             jj_consume_token(-1);
27343             throw new ParseException();
27344           }
27345           jj_consume_token(AS);
27346           ID();
27347         }
27348         break;
27349       default:
27350         jj_la1[411] = jj_gen;
27351         ;
27352       }
27353       switch (jj_nt.kind) {
27354       case FOREACHROW:
27355         jj_consume_token(FOREACHROW);
27356         break;
27357       default:
27358         jj_la1[412] = jj_gen;
27359         ;
27360       }
27361       switch (jj_nt.kind) {
27362       case REVERSE:
27363       case FORWARD:
27364       case CROSSEDITION:
27365         switch (jj_nt.kind) {
27366         case REVERSE:
27367         case FORWARD:
27368           switch (jj_nt.kind) {
27369           case FORWARD:
27370             jj_consume_token(FORWARD);
27371             break;
27372           case REVERSE:
27373             jj_consume_token(REVERSE);
27374             break;
27375           default:
27376             jj_la1[413] = jj_gen;
27377             jj_consume_token(-1);
27378             throw new ParseException();
27379           }
27380           break;
27381         default:
27382           jj_la1[414] = jj_gen;
27383           ;
27384         }
27385         jj_consume_token(CROSSEDITION);
27386         break;
27387       default:
27388         jj_la1[415] = jj_gen;
27389         ;
27390       }
27391       switch (jj_nt.kind) {
27392       case FOLLOWS:
27393       case PRECEDES:
27394         switch (jj_nt.kind) {
27395         case FOLLOWS:
27396           jj_consume_token(FOLLOWS);
27397           break;
27398         case PRECEDES:
27399           jj_consume_token(PRECEDES);
27400           break;
27401         default:
27402           jj_la1[416] = jj_gen;
27403           jj_consume_token(-1);
27404           throw new ParseException();
27405         }
27406         if (jj_2_77(2)) {
27407           ID();
27408           jj_consume_token(3);
27409         } else {
27410           ;
27411         }
27412         ID();
27413         label_98:
27414         while (true) {
27415           switch (jj_nt.kind) {
27416           case 6:
27417             ;
27418             break;
27419           default:
27420             jj_la1[417] = jj_gen;
27421             break label_98;
27422           }
27423           jj_consume_token(6);
27424           if (jj_2_78(2)) {
27425             ID();
27426             jj_consume_token(3);
27427           } else {
27428             ;
27429           }
27430           ID();
27431         }
27432         break;
27433       default:
27434         jj_la1[418] = jj_gen;
27435         ;
27436       }
27437       switch (jj_nt.kind) {
27438       case DISABLE:
27439       case ENABLE:
27440         switch (jj_nt.kind) {
27441         case ENABLE:
27442           jj_consume_token(ENABLE);
27443           break;
27444         case DISABLE:
27445           jj_consume_token(DISABLE);
27446           break;
27447         default:
27448           jj_la1[419] = jj_gen;
27449           jj_consume_token(-1);
27450           throw new ParseException();
27451         }
27452         break;
27453       default:
27454         jj_la1[420] = jj_gen;
27455         ;
27456       }
27457       switch (jj_nt.kind) {
27458       case WHEN:
27459         jj_consume_token(WHEN);
27460         jj_consume_token(5);
27461         ConditionalOrExpression();
27462         jj_consume_token(7);
27463         break;
27464       default:
27465         jj_la1[421] = jj_gen;
27466         ;
27467       }
27468       switch (jj_nt.kind) {
27469       case CALL:
27470         jj_consume_token(CALL);
27471         PrimaryExpression();
27472         jj_consume_token(4);
27473         break;
27474       case COMPOUND:
27475         CompoundTriggerBlock();
27476         break;
27477       case BEGIN:
27478       case DECLARE:
27479         Block();
27480         jj_consume_token(4);
27481         break;
27482       default:
27483         jj_la1[422] = jj_gen;
27484         jj_consume_token(-1);
27485         throw new ParseException();
27486       }
27487         jjtree.closeNodeScope(jjtn000, true);
27488         jjtc000 = false;
27489         jjtn000.setImage(simpleNode.getImage()) ;  {if (true) return jjtn000 ;}
27490     } catch (Throwable jjte000) {
27491           if (jjtc000) {
27492             jjtree.clearNodeScope(jjtn000);
27493             jjtc000 = false;
27494           } else {
27495             jjtree.popNode();
27496           }
27497           if (jjte000 instanceof RuntimeException) {
27498             {if (true) throw (RuntimeException)jjte000;}
27499           }
27500           if (jjte000 instanceof ParseException) {
27501             {if (true) throw (ParseException)jjte000;}
27502           }
27503           {if (true) throw (Error)jjte000;}
27504     } finally {
27505           if (jjtc000) {
27506             jjtree.closeNodeScope(jjtn000, true);
27507           }
27508     }
27509     throw new Error("Missing return statement in function");
27510   }
27511 
27512   final public ASTTriggerTimingPointSection TriggerTimingPointSection() throws ParseException {
27513  /*@bgen(jjtree) TriggerTimingPointSection */
27514  ASTTriggerTimingPointSection jjtn000 = new ASTTriggerTimingPointSection(this, JJTTRIGGERTIMINGPOINTSECTION);
27515  boolean jjtc000 = true;
27516  jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
27517     try {
27518       switch (jj_nt.kind) {
27519       case BEFORE:
27520         jj_consume_token(BEFORE);
27521         break;
27522       case AFTER:
27523         jj_consume_token(AFTER);
27524         break;
27525       case INSTEADOF:
27526         jj_consume_token(INSTEADOF);
27527         break;
27528       default:
27529         jj_la1[423] = jj_gen;
27530         jj_consume_token(-1);
27531         throw new ParseException();
27532       }
27533                                         sb.append(token.image) ;
27534       switch (jj_nt.kind) {
27535       case STATEMENT:
27536         jj_consume_token(STATEMENT);
27537         break;
27538       case EACH:
27539         jj_consume_token(EACH);
27540         jj_consume_token(ROW);
27541         break;
27542       default:
27543         jj_la1[424] = jj_gen;
27544         jj_consume_token(-1);
27545         throw new ParseException();
27546       }
27547                                      sb.append(" "); sb.append(token.image) ;
27548       jj_consume_token(IS);
27549       jj_consume_token(BEGIN);
27550       label_99:
27551       while (true) {
27552         Statement();
27553         switch (jj_nt.kind) {
27554         case 5:
27555         case 16:
27556         case 17:
27557         case 21:
27558         case REPLACE:
27559         case DEFINER:
27560         case CURRENT_USER:
27561         case LANGUAGE:
27562         case ADD:
27563         case AGGREGATE:
27564         case ARRAY:
27565         case AT:
27566         case ATTRIBUTE:
27567         case AUTHID:
27568         case BEGIN:
27569         case BODY:
27570         case BULK:
27571         case BYTE:
27572         case CASCADE:
27573         case CASE:
27574         case CLOSE:
27575         case COALESCE:
27576         case COLLECT:
27577         case COLUMN:
27578         case COMMENT:
27579         case COMMIT:
27580         case CONSTRUCTOR:
27581         case CONTINUE:
27582         case CONVERT:
27583         case CURRENT:
27584         case CURSOR:
27585         case DATA:
27586         case DATE:
27587         case DAY:
27588         case DECLARE:
27589         case DELETE:
27590         case DISABLE:
27591         case EDITIONABLE:
27592         case ELEMENT:
27593         case ENABLE:
27594         case ESCAPE:
27595         case EXCEPT:
27596         case EXCEPTIONS:
27597         case EXECUTE:
27598         case EXIT:
27599         case EXTERNAL:
27600         case EXTENDS:
27601         case EXTRACT:
27602         case FALSE:
27603         case FETCH:
27604         case FINAL:
27605         case FOR:
27606         case FORALL:
27607         case FORCE:
27608         case FUNCTION:
27609         case GLOBAL:
27610         case GOTO:
27611         case HASH:
27612         case HEAP:
27613         case HOUR:
27614         case IF:
27615         case IMMEDIATE:
27616         case INDICES:
27617         case INDEXTYPE:
27618         case INDICATOR:
27619         case INSERT:
27620         case INSTANTIABLE:
27621         case INTERVAL:
27622         case INVALIDATE:
27623         case ISOLATION:
27624         case JAVA:
27625         case LEVEL:
27626         case LIMIT:
27627         case LOCK:
27628         case LOOP:
27629         case MAP:
27630         case MAX:
27631         case MEMBER:
27632         case MERGE:
27633         case MIN:
27634         case MINUTE:
27635         case MLSLABEL:
27636         case MODIFY:
27637         case MOD:
27638         case MONTH:
27639         case NATURAL:
27640         case NEW:
27641         case NEW_DOT:
27642         case NO:
27643         case NONEDITIONABLE:
27644         case NOT:
27645         case NULL:
27646         case NULLIF:
27647         case OBJECT:
27648         case OID:
27649         case OPAQUE:
27650         case OPEN:
27651         case OPERATOR:
27652         case ORGANIZATION:
27653         case OTHERS:
27654         case OVERRIDING:
27655         case PACKAGE:
27656         case PARTITION:
27657         case PIPE:
27658         case PRESERVE:
27659         case PRIVATE:
27660         case PROCEDURE:
27661         case RAISE:
27662         case RANGE:
27663         case RAW:
27664         case REAL:
27665         case RECORD:
27666         case REF:
27667         case RELEASE:
27668         case RELIES_ON:
27669         case RENAME:
27670         case RESULT:
27671         case RETURN:
27672         case RETURNING:
27673         case REVERSE:
27674         case ROLLBACK:
27675         case ROW:
27676         case ROWS:
27677         case ROWID:
27678         case ROWNUM:
27679         case SAVE:
27680         case SAVEPOINT:
27681         case SECOND:
27682         case SELECT:
27683         case SELF:
27684         case SET:
27685         case SPACE:
27686         case SQL:
27687         case SQLCODE:
27688         case SQLERRM:
27689         case STATIC:
27690         case SUBTYPE:
27691         case SUBSTITUTABLE:
27692         case SUCCESSFUL:
27693         case SYSDATE:
27694         case SYS_REFCURSOR:
27695         case TEMPORARY:
27696         case TIME:
27697         case TIMESTAMP:
27698         case TIMEZONE_REGION:
27699         case TIMEZONE_ABBR:
27700         case TIMEZONE_MINUTE:
27701         case TIMEZONE_HOUR:
27702         case TRANSACTION:
27703         case TRUE:
27704         case TYPE:
27705         case UNDER:
27706         case USING:
27707         case WHILE:
27708         case YES:
27709         case SHOW:
27710         case A:
27711         case UPDATE:
27712         case DOUBLE:
27713         case DEC:
27714         case PRECISION:
27715         case INT:
27716         case NUMERIC:
27717         case NCHAR:
27718         case NVARCHAR2:
27719         case STRING:
27720         case UROWID:
27721         case VARRAY:
27722         case VARYING:
27723         case BFILE:
27724         case BLOB:
27725         case CLOB:
27726         case NCLOB:
27727         case YEAR:
27728         case LOCAL:
27729         case WITH:
27730         case ZONE:
27731         case CHARACTER:
27732         case AFTER:
27733         case BEFORE:
27734         case OLD:
27735         case PARENT:
27736         case CC_IF:
27737         case CC_ERROR:
27738         case ANALYZE:
27739         case ASSOCIATE:
27740         case AUDIT:
27741         case COMPOUND:
27742         case DATABASE:
27743         case CALL:
27744         case DDL:
27745         case DISASSOCIATE:
27746         case EACH:
27747         case FOLLOWS:
27748         case LOGOFF:
27749         case LOGON:
27750         case NESTED:
27751         case NOAUDIT:
27752         case SCHEMA:
27753         case SERVERERROR:
27754         case SHUTDOWN:
27755         case STARTUP:
27756         case STATEMENT:
27757         case STATISTICS:
27758         case SUSPEND:
27759         case TRUNCATE:
27760         case WRAPPED:
27761         case LIBRARY:
27762         case NAME:
27763         case STRUCT:
27764         case CONTEXT:
27765         case PARAMETERS:
27766         case LENGTH:
27767         case TDO:
27768         case MAXLEN:
27769         case CHARSETID:
27770         case CHARSETFORM:
27771         case ACCEPT:
27772         case ACCESSIBLE:
27773         case COPY:
27774         case DEFINE:
27775         case DISCONNECT:
27776         case HOST:
27777         case PRINT:
27778         case QUIT:
27779         case REMARK:
27780         case UNDEFINE:
27781         case VARIABLE:
27782         case WHENEVER:
27783         case ATTACH:
27784         case CAST:
27785         case TREAT:
27786         case TRIM:
27787         case LEFT:
27788         case RIGHT:
27789         case BOTH:
27790         case EMPTY:
27791         case MULTISET:
27792         case SUBMULTISET:
27793         case LEADING:
27794         case TRAILING:
27795         case CHAR_CS:
27796         case NCHAR_CS:
27797         case DBTIMEZONE:
27798         case SESSIONTIMEZONE:
27799         case AUTHENTICATED:
27800         case LINK:
27801         case SHARED:
27802         case DIRECTORY:
27803         case USER:
27804         case IDENTIFIER:
27805         case UNSIGNED_NUMERIC_LITERAL:
27806         case CHARACTER_LITERAL:
27807         case STRING_LITERAL:
27808         case QUOTED_LITERAL:
27809           ;
27810           break;
27811         default:
27812           jj_la1[425] = jj_gen;
27813           break label_99;
27814         }
27815       }
27816       jj_consume_token(END);
27817       switch (jj_nt.kind) {
27818       case BEFORE:
27819         jj_consume_token(BEFORE);
27820         break;
27821       case AFTER:
27822         jj_consume_token(AFTER);
27823         break;
27824       case INSTEADOF:
27825         jj_consume_token(INSTEADOF);
27826         break;
27827       default:
27828         jj_la1[426] = jj_gen;
27829         jj_consume_token(-1);
27830         throw new ParseException();
27831       }
27832       switch (jj_nt.kind) {
27833       case STATEMENT:
27834         jj_consume_token(STATEMENT);
27835         break;
27836       case EACH:
27837         jj_consume_token(EACH);
27838         jj_consume_token(ROW);
27839         break;
27840       default:
27841         jj_la1[427] = jj_gen;
27842         jj_consume_token(-1);
27843         throw new ParseException();
27844       }
27845       jj_consume_token(4);
27846 
27847    jjtree.closeNodeScope(jjtn000, true);
27848    jjtc000 = false;
27849    jjtn000.setImage(sb.toString()) ;  {if (true) return jjtn000 ;}
27850     } catch (Throwable jjte000) {
27851    if (jjtc000) {
27852      jjtree.clearNodeScope(jjtn000);
27853      jjtc000 = false;
27854    } else {
27855      jjtree.popNode();
27856    }
27857    if (jjte000 instanceof RuntimeException) {
27858      {if (true) throw (RuntimeException)jjte000;}
27859    }
27860    if (jjte000 instanceof ParseException) {
27861      {if (true) throw (ParseException)jjte000;}
27862    }
27863    {if (true) throw (Error)jjte000;}
27864     } finally {
27865    if (jjtc000) {
27866      jjtree.closeNodeScope(jjtn000, true);
27867    }
27868     }
27869     throw new Error("Missing return statement in function");
27870   }
27871 
27872   final public ASTCompoundTriggerBlock CompoundTriggerBlock() throws ParseException {
27873  /*@bgen(jjtree) CompoundTriggerBlock */
27874   ASTCompoundTriggerBlock jjtn000 = new ASTCompoundTriggerBlock(this, JJTCOMPOUNDTRIGGERBLOCK);
27875   boolean jjtc000 = true;
27876   jjtree.openNodeScope(jjtn000);
27877     try {
27878       jj_consume_token(COMPOUND);
27879       jj_consume_token(TRIGGER);
27880       label_100:
27881       while (true) {
27882         switch (jj_nt.kind) {
27883         case REPLACE:
27884         case DEFINER:
27885         case CURRENT_USER:
27886         case SERIALLY_REUSABLE:
27887         case RESTRICT_REFERENCES:
27888         case EXCEPTION_INIT:
27889         case AUTONOMOUS_TRANSACTION:
27890         case LANGUAGE:
27891         case ADD:
27892         case AGGREGATE:
27893         case ALL:
27894         case ALTER:
27895         case AND:
27896         case ANY:
27897         case ARRAY:
27898         case AS:
27899         case ASC:
27900         case AT:
27901         case ATTRIBUTE:
27902         case AUTHID:
27903         case AVG:
27904         case BETWEEN:
27905         case BINARY_INTEGER:
27906         case BODY:
27907         case BOOLEAN:
27908         case BULK:
27909         case BY:
27910         case BYTE:
27911         case CASCADE:
27912         case CASE:
27913         case CHAR:
27914         case CHAR_BASE:
27915         case CHECK:
27916         case CLOSE:
27917         case CLUSTER:
27918         case COALESCE:
27919         case COLLECT:
27920         case COLUMN:
27921         case COMMENT:
27922         case COMMIT:
27923         case COMPRESS:
27924         case CONNECT:
27925         case CONSTANT:
27926         case CONSTRUCTOR:
27927         case CONTINUE:
27928         case CONVERT:
27929         case CREATE:
27930         case CURRENT:
27931         case CURRVAL:
27932         case CURSOR:
27933         case DATA:
27934         case DATE:
27935         case DAY:
27936         case DECLARE:
27937         case DECIMAL:
27938         case _DEFAULT:
27939         case DELETE:
27940         case DESC:
27941         case DISABLE:
27942         case DISTINCT:
27943         case DO:
27944         case DROP:
27945         case EDITIONABLE:
27946         case ELEMENT:
27947         case ELSE:
27948         case ELSIF:
27949         case ENABLE:
27950         case ESCAPE:
27951         case EXCEPT:
27952         case EXCEPTION:
27953         case EXCEPTIONS:
27954         case EXCLUSIVE:
27955         case EXECUTE:
27956         case EXISTS:
27957         case EXIT:
27958         case EXTERNAL:
27959         case EXTENDS:
27960         case EXTRACT:
27961         case FALSE:
27962         case FETCH:
27963         case FINAL:
27964         case FLOAT:
27965         case FOR:
27966         case FORALL:
27967         case FORCE:
27968         case FROM:
27969         case FUNCTION:
27970         case GLOBAL:
27971         case GOTO:
27972         case GROUP:
27973         case HASH:
27974         case HAVING:
27975         case HEAP:
27976         case HOUR:
27977         case IF:
27978         case IMMEDIATE:
27979         case IN:
27980         case INDEX:
27981         case INDICES:
27982         case INDEXTYPE:
27983         case INDICATOR:
27984         case INSERT:
27985         case INSTANTIABLE:
27986         case INTEGER:
27987         case INTERFACE:
27988         case INTERSECT:
27989         case INTERVAL:
27990         case INTO:
27991         case INVALIDATE:
27992         case IS:
27993         case ISOLATION:
27994         case JAVA:
27995         case LEVEL:
27996         case LIKE:
27997         case LIMIT:
27998         case LIMITED:
27999         case LOCK:
28000         case LONG:
28001         case LOOP:
28002         case MAP:
28003         case MAX:
28004         case MEMBER:
28005         case MERGE:
28006         case MIN:
28007         case MINUS:
28008         case MINUTE:
28009         case MLSLABEL:
28010         case MODIFY:
28011         case MOD:
28012         case MODE:
28013         case MONTH:
28014         case NATURAL:
28015         case NATURALN:
28016         case NEW:
28017         case NEXTVAL:
28018         case NO:
28019         case NOCOPY:
28020         case NONEDITIONABLE:
28021         case NOT:
28022         case NOWAIT:
28023         case NULL:
28024         case NULLIF:
28025         case NUMBER:
28026         case BFILE_BASE:
28027         case BLOB_BASE:
28028         case CLOB_BASE:
28029         case DATE_BASE:
28030         case NUMBER_BASE:
28031         case OBJECT:
28032         case OCIROWID:
28033         case OF:
28034         case OID:
28035         case ON:
28036         case OPAQUE:
28037         case OPEN:
28038         case OPERATOR:
28039         case OPTION:
28040         case OR:
28041         case ORDER:
28042         case ORGANIZATION:
28043         case OTHERS:
28044         case OUT:
28045         case OVERRIDING:
28046         case PACKAGE:
28047         case PARTITION:
28048         case PCTFREE:
28049         case PLS_INTEGER:
28050         case POSITIVE:
28051         case POSITIVEN:
28052         case PRAGMA:
28053         case PRESERVE:
28054         case PRIOR:
28055         case PROMPT:
28056         case PRIVATE:
28057         case PROCEDURE:
28058         case PUBLIC:
28059         case RAISE:
28060         case RANGE:
28061         case RAW:
28062         case REAL:
28063         case RECORD:
28064         case REF:
28065         case RELEASE:
28066         case RELIES_ON:
28067         case RENAME:
28068         case RESULT:
28069         case RETURN:
28070         case RETURNING:
28071         case REVERSE:
28072         case ROLLBACK:
28073         case ROW:
28074         case ROWS:
28075         case ROWID:
28076         case ROWNUM:
28077         case ROWTYPE:
28078         case SAVE:
28079         case SAVEPOINT:
28080         case SECOND:
28081         case SELECT:
28082         case SELF:
28083         case SEPARATE:
28084         case SET:
28085         case SHARE:
28086         case SMALLINT:
28087         case SPACE:
28088         case SQL:
28089         case SQLCODE:
28090         case SQLERRM:
28091         case START:
28092         case STATIC:
28093         case STDDEV:
28094         case SUBTYPE:
28095         case SUBSTITUTABLE:
28096         case SUCCESSFUL:
28097         case SUM:
28098         case SYNONYM:
28099         case SYSDATE:
28100         case SYS_REFCURSOR:
28101         case TABLE:
28102         case TEMPORARY:
28103         case THEN:
28104         case TIME:
28105         case TIMESTAMP:
28106         case TIMEZONE_REGION:
28107         case TIMEZONE_ABBR:
28108         case TIMEZONE_MINUTE:
28109         case TIMEZONE_HOUR:
28110         case TO:
28111         case TRANSACTION:
28112         case TRIGGER:
28113         case TRUE:
28114         case TYPE:
28115         case UI:
28116         case UNDER:
28117         case USING:
28118         case WHILE:
28119         case YES:
28120         case SHOW:
28121         case A:
28122         case UPDATE:
28123         case VARCHAR:
28124         case VARCHAR2:
28125         case DOUBLE:
28126         case DEC:
28127         case PRECISION:
28128         case INT:
28129         case NUMERIC:
28130         case SIGNTYPE:
28131         case NCHAR:
28132         case NVARCHAR2:
28133         case STRING:
28134         case UROWID:
28135         case VARRAY:
28136         case VARYING:
28137         case BFILE:
28138         case BLOB:
28139         case CLOB:
28140         case NCLOB:
28141         case YEAR:
28142         case LOCAL:
28143         case WITH:
28144         case ZONE:
28145         case CHARACTER:
28146         case AFTER:
28147         case BEFORE:
28148         case INSTEADOF:
28149         case OLD:
28150         case PARENT:
28151         case ANALYZE:
28152         case ASSOCIATE:
28153         case AUDIT:
28154         case COMPOUND:
28155         case DATABASE:
28156         case CALL:
28157         case DDL:
28158         case DISASSOCIATE:
28159         case EACH:
28160         case FOLLOWS:
28161         case LOGOFF:
28162         case LOGON:
28163         case NESTED:
28164         case NOAUDIT:
28165         case SCHEMA:
28166         case SERVERERROR:
28167         case SHUTDOWN:
28168         case STARTUP:
28169         case STATEMENT:
28170         case STATISTICS:
28171         case SUSPEND:
28172         case TRUNCATE:
28173         case WRAPPED:
28174         case LIBRARY:
28175         case NAME:
28176         case STRUCT:
28177         case CONTEXT:
28178         case PARAMETERS:
28179         case LENGTH:
28180         case TDO:
28181         case MAXLEN:
28182         case CHARSETID:
28183         case CHARSETFORM:
28184         case ACCEPT:
28185         case ACCESSIBLE:
28186         case COPY:
28187         case DEFINE:
28188         case DISCONNECT:
28189         case HOST:
28190         case PRINT:
28191         case QUIT:
28192         case REMARK:
28193         case UNDEFINE:
28194         case VARIABLE:
28195         case WHENEVER:
28196         case ATTACH:
28197         case CAST:
28198         case TREAT:
28199         case TRIM:
28200         case LEFT:
28201         case RIGHT:
28202         case BOTH:
28203         case EMPTY:
28204         case MULTISET:
28205         case SUBMULTISET:
28206         case LEADING:
28207         case TRAILING:
28208         case CHAR_CS:
28209         case NCHAR_CS:
28210         case DBTIMEZONE:
28211         case SESSIONTIMEZONE:
28212         case AUTHENTICATED:
28213         case LINK:
28214         case SHARED:
28215         case DIRECTORY:
28216         case USER:
28217         case IDENTIFIER:
28218         case QUOTED_LITERAL:
28219         case SQLDATA_CLASS:
28220         case CUSTOMDATUM_CLASS:
28221         case ORADATA_CLASS:
28222         case JAVA_INTERFACE_CLASS:
28223           ;
28224           break;
28225         default:
28226           jj_la1[428] = jj_gen;
28227           break label_100;
28228         }
28229         switch (jj_nt.kind) {
28230         case AFTER:
28231         case BEFORE:
28232         case INSTEADOF:
28233           TriggerTimingPointSection();
28234           break;
28235         case PRAGMA:
28236           Pragma();
28237           break;
28238         default:
28239           jj_la1[429] = jj_gen;
28240           if (jj_2_79(2)) {
28241             ExceptionDeclaration();
28242           } else if (jj_2_80(2)) {
28243             SubTypeDefinition();
28244           } else if (jj_2_81(4)) {
28245             VariableOrConstantDeclaration();
28246           } else if (jj_2_82(2)) {
28247             CursorSpecification();
28248           } else {
28249             switch (jj_nt.kind) {
28250             case CURSOR:
28251               CursorBody();
28252               break;
28253             case IDENTIFIER:
28254               CollectionDeclaration();
28255               break;
28256             case CREATE:
28257             case FUNCTION:
28258             case PROCEDURE:
28259               ProgramUnit();
28260               break;
28261             default:
28262               jj_la1[430] = jj_gen;
28263               jj_consume_token(-1);
28264               throw new ParseException();
28265             }
28266           }
28267         }
28268       }
28269       jj_consume_token(END);
28270       switch (jj_nt.kind) {
28271       case REPLACE:
28272       case DEFINER:
28273       case CURRENT_USER:
28274       case SERIALLY_REUSABLE:
28275       case RESTRICT_REFERENCES:
28276       case EXCEPTION_INIT:
28277       case AUTONOMOUS_TRANSACTION:
28278       case LANGUAGE:
28279       case ADD:
28280       case AGGREGATE:
28281       case ALL:
28282       case ALTER:
28283       case AND:
28284       case ANY:
28285       case ARRAY:
28286       case AS:
28287       case ASC:
28288       case AT:
28289       case ATTRIBUTE:
28290       case AUTHID:
28291       case AVG:
28292       case BETWEEN:
28293       case BINARY_INTEGER:
28294       case BODY:
28295       case BOOLEAN:
28296       case BULK:
28297       case BY:
28298       case BYTE:
28299       case CASCADE:
28300       case CASE:
28301       case CHAR:
28302       case CHAR_BASE:
28303       case CHECK:
28304       case CLOSE:
28305       case CLUSTER:
28306       case COALESCE:
28307       case COLLECT:
28308       case COLUMN:
28309       case COMMENT:
28310       case COMMIT:
28311       case COMPRESS:
28312       case CONNECT:
28313       case CONSTANT:
28314       case CONSTRUCTOR:
28315       case CONTINUE:
28316       case CONVERT:
28317       case CREATE:
28318       case CURRENT:
28319       case CURRVAL:
28320       case CURSOR:
28321       case DATA:
28322       case DATE:
28323       case DAY:
28324       case DECLARE:
28325       case DECIMAL:
28326       case _DEFAULT:
28327       case DELETE:
28328       case DESC:
28329       case DISABLE:
28330       case DISTINCT:
28331       case DO:
28332       case DROP:
28333       case EDITIONABLE:
28334       case ELEMENT:
28335       case ELSE:
28336       case ELSIF:
28337       case ENABLE:
28338       case ESCAPE:
28339       case EXCEPT:
28340       case EXCEPTION:
28341       case EXCEPTIONS:
28342       case EXCLUSIVE:
28343       case EXECUTE:
28344       case EXISTS:
28345       case EXIT:
28346       case EXTERNAL:
28347       case EXTENDS:
28348       case EXTRACT:
28349       case FALSE:
28350       case FETCH:
28351       case FINAL:
28352       case FLOAT:
28353       case FOR:
28354       case FORALL:
28355       case FORCE:
28356       case FROM:
28357       case FUNCTION:
28358       case GLOBAL:
28359       case GOTO:
28360       case GROUP:
28361       case HASH:
28362       case HAVING:
28363       case HEAP:
28364       case HOUR:
28365       case IF:
28366       case IMMEDIATE:
28367       case IN:
28368       case INDEX:
28369       case INDICES:
28370       case INDEXTYPE:
28371       case INDICATOR:
28372       case INSERT:
28373       case INSTANTIABLE:
28374       case INTEGER:
28375       case INTERFACE:
28376       case INTERSECT:
28377       case INTERVAL:
28378       case INTO:
28379       case INVALIDATE:
28380       case IS:
28381       case ISOLATION:
28382       case JAVA:
28383       case LEVEL:
28384       case LIKE:
28385       case LIMIT:
28386       case LIMITED:
28387       case LOCK:
28388       case LONG:
28389       case LOOP:
28390       case MAP:
28391       case MAX:
28392       case MEMBER:
28393       case MERGE:
28394       case MIN:
28395       case MINUS:
28396       case MINUTE:
28397       case MLSLABEL:
28398       case MODIFY:
28399       case MOD:
28400       case MODE:
28401       case MONTH:
28402       case NATURAL:
28403       case NATURALN:
28404       case NEW:
28405       case NEXTVAL:
28406       case NO:
28407       case NOCOPY:
28408       case NONEDITIONABLE:
28409       case NOT:
28410       case NOWAIT:
28411       case NULL:
28412       case NULLIF:
28413       case NUMBER:
28414       case BFILE_BASE:
28415       case BLOB_BASE:
28416       case CLOB_BASE:
28417       case DATE_BASE:
28418       case NUMBER_BASE:
28419       case OBJECT:
28420       case OCIROWID:
28421       case OF:
28422       case OID:
28423       case ON:
28424       case OPAQUE:
28425       case OPEN:
28426       case OPERATOR:
28427       case OPTION:
28428       case OR:
28429       case ORDER:
28430       case ORGANIZATION:
28431       case OTHERS:
28432       case OUT:
28433       case OVERRIDING:
28434       case PACKAGE:
28435       case PARTITION:
28436       case PCTFREE:
28437       case PLS_INTEGER:
28438       case POSITIVE:
28439       case POSITIVEN:
28440       case PRESERVE:
28441       case PRIOR:
28442       case PROMPT:
28443       case PRIVATE:
28444       case PROCEDURE:
28445       case PUBLIC:
28446       case RAISE:
28447       case RANGE:
28448       case RAW:
28449       case REAL:
28450       case RECORD:
28451       case REF:
28452       case RELEASE:
28453       case RELIES_ON:
28454       case RENAME:
28455       case RESULT:
28456       case RETURN:
28457       case RETURNING:
28458       case REVERSE:
28459       case ROLLBACK:
28460       case ROW:
28461       case ROWS:
28462       case ROWID:
28463       case ROWNUM:
28464       case ROWTYPE:
28465       case SAVE:
28466       case SAVEPOINT:
28467       case SECOND:
28468       case SELECT:
28469       case SELF:
28470       case SEPARATE:
28471       case SET:
28472       case SHARE:
28473       case SMALLINT:
28474       case SPACE:
28475       case SQL:
28476       case SQLCODE:
28477       case SQLERRM:
28478       case START:
28479       case STATIC:
28480       case STDDEV:
28481       case SUBTYPE:
28482       case SUBSTITUTABLE:
28483       case SUCCESSFUL:
28484       case SUM:
28485       case SYNONYM:
28486       case SYSDATE:
28487       case SYS_REFCURSOR:
28488       case TABLE:
28489       case TEMPORARY:
28490       case THEN:
28491       case TIME:
28492       case TIMESTAMP:
28493       case TIMEZONE_REGION:
28494       case TIMEZONE_ABBR:
28495       case TIMEZONE_MINUTE:
28496       case TIMEZONE_HOUR:
28497       case TO:
28498       case TRANSACTION:
28499       case TRIGGER:
28500       case TRUE:
28501       case TYPE:
28502       case UI:
28503       case UNDER:
28504       case USING:
28505       case WHILE:
28506       case YES:
28507       case SHOW:
28508       case A:
28509       case UPDATE:
28510       case VARCHAR:
28511       case VARCHAR2:
28512       case DOUBLE:
28513       case DEC:
28514       case PRECISION:
28515       case INT:
28516       case NUMERIC:
28517       case SIGNTYPE:
28518       case NCHAR:
28519       case NVARCHAR2:
28520       case STRING:
28521       case UROWID:
28522       case VARRAY:
28523       case VARYING:
28524       case BFILE:
28525       case BLOB:
28526       case CLOB:
28527       case NCLOB:
28528       case YEAR:
28529       case LOCAL:
28530       case WITH:
28531       case ZONE:
28532       case CHARACTER:
28533       case AFTER:
28534       case BEFORE:
28535       case OLD:
28536       case PARENT:
28537       case ANALYZE:
28538       case ASSOCIATE:
28539       case AUDIT:
28540       case COMPOUND:
28541       case DATABASE:
28542       case CALL:
28543       case DDL:
28544       case DISASSOCIATE:
28545       case EACH:
28546       case FOLLOWS:
28547       case LOGOFF:
28548       case LOGON:
28549       case NESTED:
28550       case NOAUDIT:
28551       case SCHEMA:
28552       case SERVERERROR:
28553       case SHUTDOWN:
28554       case STARTUP:
28555       case STATEMENT:
28556       case STATISTICS:
28557       case SUSPEND:
28558       case TRUNCATE:
28559       case WRAPPED:
28560       case LIBRARY:
28561       case NAME:
28562       case STRUCT:
28563       case CONTEXT:
28564       case PARAMETERS:
28565       case LENGTH:
28566       case TDO:
28567       case MAXLEN:
28568       case CHARSETID:
28569       case CHARSETFORM:
28570       case ACCEPT:
28571       case ACCESSIBLE:
28572       case COPY:
28573       case DEFINE:
28574       case DISCONNECT:
28575       case HOST:
28576       case PRINT:
28577       case QUIT:
28578       case REMARK:
28579       case UNDEFINE:
28580       case VARIABLE:
28581       case WHENEVER:
28582       case ATTACH:
28583       case CAST:
28584       case TREAT:
28585       case TRIM:
28586       case LEFT:
28587       case RIGHT:
28588       case BOTH:
28589       case EMPTY:
28590       case MULTISET:
28591       case SUBMULTISET:
28592       case LEADING:
28593       case TRAILING:
28594       case CHAR_CS:
28595       case NCHAR_CS:
28596       case DBTIMEZONE:
28597       case SESSIONTIMEZONE:
28598       case AUTHENTICATED:
28599       case LINK:
28600       case SHARED:
28601       case DIRECTORY:
28602       case USER:
28603       case IDENTIFIER:
28604       case QUOTED_LITERAL:
28605       case SQLDATA_CLASS:
28606       case CUSTOMDATUM_CLASS:
28607       case ORADATA_CLASS:
28608       case JAVA_INTERFACE_CLASS:
28609         ID();
28610         break;
28611       default:
28612         jj_la1[431] = jj_gen;
28613         ;
28614       }
28615       jj_consume_token(4);
28616         jjtree.closeNodeScope(jjtn000, true);
28617         jjtc000 = false;
28618         {if (true) return jjtn000 ;}
28619     } catch (Throwable jjte000) {
28620     if (jjtc000) {
28621       jjtree.clearNodeScope(jjtn000);
28622       jjtc000 = false;
28623     } else {
28624       jjtree.popNode();
28625     }
28626     if (jjte000 instanceof RuntimeException) {
28627       {if (true) throw (RuntimeException)jjte000;}
28628     }
28629     if (jjte000 instanceof ParseException) {
28630       {if (true) throw (ParseException)jjte000;}
28631     }
28632     {if (true) throw (Error)jjte000;}
28633     } finally {
28634     if (jjtc000) {
28635       jjtree.closeNodeScope(jjtn000, true);
28636     }
28637     }
28638     throw new Error("Missing return statement in function");
28639   }
28640 
28641 /*
28642 non_dml_trigger :
28643 (BEFORE> |<AFTER> ) 
28644 (DDLEvent | database_event) ( OR (DDLEvent | database_event))*
28645 ON
28646 (DATABASE | [schema.]SCHEMA
28647 */
28648   final public ASTNonDMLTrigger NonDMLTrigger() throws ParseException {
28649  /*@bgen(jjtree) NonDMLTrigger */
28650   ASTNonDMLTrigger jjtn000 = new ASTNonDMLTrigger(this, JJTNONDMLTRIGGER);
28651   boolean jjtc000 = true;
28652   jjtree.openNodeScope(jjtn000);
28653     try {
28654       switch (jj_nt.kind) {
28655       case BEFORE:
28656         jj_consume_token(BEFORE);
28657         break;
28658       case AFTER:
28659         jj_consume_token(AFTER);
28660         break;
28661       default:
28662         jj_la1[432] = jj_gen;
28663         jj_consume_token(-1);
28664         throw new ParseException();
28665       }
28666       switch (jj_nt.kind) {
28667       case ALTER:
28668       case COMMENT:
28669       case CREATE:
28670       case DROP:
28671       case GRANT:
28672       case RENAME:
28673       case REVOKE:
28674       case ANALYZE:
28675       case ASSOCIATE:
28676       case AUDIT:
28677       case DDL:
28678       case DISASSOCIATE:
28679       case NOAUDIT:
28680       case TRUNCATE:
28681         DDLEvent();
28682         break;
28683       case LOGOFF:
28684       case LOGON:
28685       case SERVERERROR:
28686       case SHUTDOWN:
28687       case STARTUP:
28688       case SUSPEND:
28689         DatabaseEvent();
28690         break;
28691       default:
28692         jj_la1[433] = jj_gen;
28693         jj_consume_token(-1);
28694         throw new ParseException();
28695       }
28696       label_101:
28697       while (true) {
28698         switch (jj_nt.kind) {
28699         case OR:
28700           ;
28701           break;
28702         default:
28703           jj_la1[434] = jj_gen;
28704           break label_101;
28705         }
28706         jj_consume_token(OR);
28707         switch (jj_nt.kind) {
28708         case ALTER:
28709         case COMMENT:
28710         case CREATE:
28711         case DROP:
28712         case GRANT:
28713         case RENAME:
28714         case REVOKE:
28715         case ANALYZE:
28716         case ASSOCIATE:
28717         case AUDIT:
28718         case DDL:
28719         case DISASSOCIATE:
28720         case NOAUDIT:
28721         case TRUNCATE:
28722           DDLEvent();
28723           break;
28724         case LOGOFF:
28725         case LOGON:
28726         case SERVERERROR:
28727         case SHUTDOWN:
28728         case STARTUP:
28729         case SUSPEND:
28730           DatabaseEvent();
28731           break;
28732         default:
28733           jj_la1[435] = jj_gen;
28734           jj_consume_token(-1);
28735           throw new ParseException();
28736         }
28737       }
28738       jj_consume_token(ON);
28739       switch (jj_nt.kind) {
28740       case DATABASE:
28741         jj_consume_token(DATABASE);
28742         break;
28743       case REPLACE:
28744       case DEFINER:
28745       case CURRENT_USER:
28746       case SERIALLY_REUSABLE:
28747       case RESTRICT_REFERENCES:
28748       case EXCEPTION_INIT:
28749       case AUTONOMOUS_TRANSACTION:
28750       case LANGUAGE:
28751       case ADD:
28752       case AGGREGATE:
28753       case ALL:
28754       case ALTER:
28755       case AND:
28756       case ANY:
28757       case ARRAY:
28758       case AS:
28759       case ASC:
28760       case AT:
28761       case ATTRIBUTE:
28762       case AUTHID:
28763       case AVG:
28764       case BETWEEN:
28765       case BINARY_INTEGER:
28766       case BODY:
28767       case BOOLEAN:
28768       case BULK:
28769       case BY:
28770       case BYTE:
28771       case CASCADE:
28772       case CASE:
28773       case CHAR:
28774       case CHAR_BASE:
28775       case CHECK:
28776       case CLOSE:
28777       case CLUSTER:
28778       case COALESCE:
28779       case COLLECT:
28780       case COLUMN:
28781       case COMMENT:
28782       case COMMIT:
28783       case COMPRESS:
28784       case CONNECT:
28785       case CONSTANT:
28786       case CONSTRUCTOR:
28787       case CONTINUE:
28788       case CONVERT:
28789       case CREATE:
28790       case CURRENT:
28791       case CURRVAL:
28792       case CURSOR:
28793       case DATA:
28794       case DATE:
28795       case DAY:
28796       case DECLARE:
28797       case DECIMAL:
28798       case _DEFAULT:
28799       case DELETE:
28800       case DESC:
28801       case DISABLE:
28802       case DISTINCT:
28803       case DO:
28804       case DROP:
28805       case EDITIONABLE:
28806       case ELEMENT:
28807       case ELSE:
28808       case ELSIF:
28809       case ENABLE:
28810       case ESCAPE:
28811       case EXCEPT:
28812       case EXCEPTION:
28813       case EXCEPTIONS:
28814       case EXCLUSIVE:
28815       case EXECUTE:
28816       case EXISTS:
28817       case EXIT:
28818       case EXTERNAL:
28819       case EXTENDS:
28820       case EXTRACT:
28821       case FALSE:
28822       case FETCH:
28823       case FINAL:
28824       case FLOAT:
28825       case FOR:
28826       case FORALL:
28827       case FORCE:
28828       case FROM:
28829       case FUNCTION:
28830       case GLOBAL:
28831       case GOTO:
28832       case GROUP:
28833       case HASH:
28834       case HAVING:
28835       case HEAP:
28836       case HOUR:
28837       case IF:
28838       case IMMEDIATE:
28839       case IN:
28840       case INDEX:
28841       case INDICES:
28842       case INDEXTYPE:
28843       case INDICATOR:
28844       case INSERT:
28845       case INSTANTIABLE:
28846       case INTEGER:
28847       case INTERFACE:
28848       case INTERSECT:
28849       case INTERVAL:
28850       case INTO:
28851       case INVALIDATE:
28852       case IS:
28853       case ISOLATION:
28854       case JAVA:
28855       case LEVEL:
28856       case LIKE:
28857       case LIMIT:
28858       case LIMITED:
28859       case LOCK:
28860       case LONG:
28861       case LOOP:
28862       case MAP:
28863       case MAX:
28864       case MEMBER:
28865       case MERGE:
28866       case MIN:
28867       case MINUS:
28868       case MINUTE:
28869       case MLSLABEL:
28870       case MODIFY:
28871       case MOD:
28872       case MODE:
28873       case MONTH:
28874       case NATURAL:
28875       case NATURALN:
28876       case NEW:
28877       case NEXTVAL:
28878       case NO:
28879       case NOCOPY:
28880       case NONEDITIONABLE:
28881       case NOT:
28882       case NOWAIT:
28883       case NULL:
28884       case NULLIF:
28885       case NUMBER:
28886       case BFILE_BASE:
28887       case BLOB_BASE:
28888       case CLOB_BASE:
28889       case DATE_BASE:
28890       case NUMBER_BASE:
28891       case OBJECT:
28892       case OCIROWID:
28893       case OF:
28894       case OID:
28895       case ON:
28896       case OPAQUE:
28897       case OPEN:
28898       case OPERATOR:
28899       case OPTION:
28900       case OR:
28901       case ORDER:
28902       case ORGANIZATION:
28903       case OTHERS:
28904       case OUT:
28905       case OVERRIDING:
28906       case PACKAGE:
28907       case PARTITION:
28908       case PCTFREE:
28909       case PLS_INTEGER:
28910       case POSITIVE:
28911       case POSITIVEN:
28912       case PRESERVE:
28913       case PRIOR:
28914       case PROMPT:
28915       case PRIVATE:
28916       case PROCEDURE:
28917       case PUBLIC:
28918       case RAISE:
28919       case RANGE:
28920       case RAW:
28921       case REAL:
28922       case RECORD:
28923       case REF:
28924       case RELEASE:
28925       case RELIES_ON:
28926       case RENAME:
28927       case RESULT:
28928       case RETURN:
28929       case RETURNING:
28930       case REVERSE:
28931       case ROLLBACK:
28932       case ROW:
28933       case ROWS:
28934       case ROWID:
28935       case ROWNUM:
28936       case ROWTYPE:
28937       case SAVE:
28938       case SAVEPOINT:
28939       case SECOND:
28940       case SELECT:
28941       case SELF:
28942       case SEPARATE:
28943       case SET:
28944       case SHARE:
28945       case SMALLINT:
28946       case SPACE:
28947       case SQL:
28948       case SQLCODE:
28949       case SQLERRM:
28950       case START:
28951       case STATIC:
28952       case STDDEV:
28953       case SUBTYPE:
28954       case SUBSTITUTABLE:
28955       case SUCCESSFUL:
28956       case SUM:
28957       case SYNONYM:
28958       case SYSDATE:
28959       case SYS_REFCURSOR:
28960       case TABLE:
28961       case TEMPORARY:
28962       case THEN:
28963       case TIME:
28964       case TIMESTAMP:
28965       case TIMEZONE_REGION:
28966       case TIMEZONE_ABBR:
28967       case TIMEZONE_MINUTE:
28968       case TIMEZONE_HOUR:
28969       case TO:
28970       case TRANSACTION:
28971       case TRIGGER:
28972       case TRUE:
28973       case TYPE:
28974       case UI:
28975       case UNDER:
28976       case USING:
28977       case WHILE:
28978       case YES:
28979       case SHOW:
28980       case A:
28981       case UPDATE:
28982       case VARCHAR:
28983       case VARCHAR2:
28984       case DOUBLE:
28985       case DEC:
28986       case PRECISION:
28987       case INT:
28988       case NUMERIC:
28989       case SIGNTYPE:
28990       case NCHAR:
28991       case NVARCHAR2:
28992       case STRING:
28993       case UROWID:
28994       case VARRAY:
28995       case VARYING:
28996       case BFILE:
28997       case BLOB:
28998       case CLOB:
28999       case NCLOB:
29000       case YEAR:
29001       case LOCAL:
29002       case WITH:
29003       case ZONE:
29004       case CHARACTER:
29005       case AFTER:
29006       case BEFORE:
29007       case OLD:
29008       case PARENT:
29009       case ANALYZE:
29010       case ASSOCIATE:
29011       case AUDIT:
29012       case COMPOUND:
29013       case CALL:
29014       case DDL:
29015       case DISASSOCIATE:
29016       case EACH:
29017       case FOLLOWS:
29018       case LOGOFF:
29019       case LOGON:
29020       case NESTED:
29021       case NOAUDIT:
29022       case SCHEMA:
29023       case SERVERERROR:
29024       case SHUTDOWN:
29025       case STARTUP:
29026       case STATEMENT:
29027       case STATISTICS:
29028       case SUSPEND:
29029       case TRUNCATE:
29030       case WRAPPED:
29031       case LIBRARY:
29032       case NAME:
29033       case STRUCT:
29034       case CONTEXT:
29035       case PARAMETERS:
29036       case LENGTH:
29037       case TDO:
29038       case MAXLEN:
29039       case CHARSETID:
29040       case CHARSETFORM:
29041       case ACCEPT:
29042       case ACCESSIBLE:
29043       case COPY:
29044       case DEFINE:
29045       case DISCONNECT:
29046       case HOST:
29047       case PRINT:
29048       case QUIT:
29049       case REMARK:
29050       case UNDEFINE:
29051       case VARIABLE:
29052       case WHENEVER:
29053       case ATTACH:
29054       case CAST:
29055       case TREAT:
29056       case TRIM:
29057       case LEFT:
29058       case RIGHT:
29059       case BOTH:
29060       case EMPTY:
29061       case MULTISET:
29062       case SUBMULTISET:
29063       case LEADING:
29064       case TRAILING:
29065       case CHAR_CS:
29066       case NCHAR_CS:
29067       case DBTIMEZONE:
29068       case SESSIONTIMEZONE:
29069       case AUTHENTICATED:
29070       case LINK:
29071       case SHARED:
29072       case DIRECTORY:
29073       case USER:
29074       case IDENTIFIER:
29075       case QUOTED_LITERAL:
29076       case SQLDATA_CLASS:
29077       case CUSTOMDATUM_CLASS:
29078       case ORADATA_CLASS:
29079       case JAVA_INTERFACE_CLASS:
29080         if (jj_2_83(2)) {
29081           ID();
29082           jj_consume_token(3);
29083         } else {
29084           ;
29085         }
29086         jj_consume_token(SCHEMA);
29087         break;
29088       default:
29089         jj_la1[436] = jj_gen;
29090         jj_consume_token(-1);
29091         throw new ParseException();
29092       }
29093         jjtree.closeNodeScope(jjtn000, true);
29094         jjtc000 = false;
29095         {if (true) return jjtn000 ;}
29096     } catch (Throwable jjte000) {
29097    if (jjtc000) {
29098      jjtree.clearNodeScope(jjtn000);
29099      jjtc000 = false;
29100    } else {
29101      jjtree.popNode();
29102    }
29103    if (jjte000 instanceof RuntimeException) {
29104      {if (true) throw (RuntimeException)jjte000;}
29105    }
29106    if (jjte000 instanceof ParseException) {
29107      {if (true) throw (ParseException)jjte000;}
29108    }
29109    {if (true) throw (Error)jjte000;}
29110     } finally {
29111    if (jjtc000) {
29112      jjtree.closeNodeScope(jjtn000, true);
29113    }
29114     }
29115     throw new Error("Missing return statement in function");
29116   }
29117 
29118   final public ASTDDLEvent DDLEvent() throws ParseException {
29119                          /*@bgen(jjtree) DDLEvent */
29120   ASTDDLEvent jjtn000 = new ASTDDLEvent(this, JJTDDLEVENT);
29121   boolean jjtc000 = true;
29122   jjtree.openNodeScope(jjtn000);
29123     try {
29124       switch (jj_nt.kind) {
29125       case ALTER:
29126         jj_consume_token(ALTER);
29127         break;
29128       case ANALYZE:
29129         jj_consume_token(ANALYZE);
29130         break;
29131       case ASSOCIATE:
29132         jj_consume_token(ASSOCIATE);
29133         jj_consume_token(STATISTICS);
29134         break;
29135       case AUDIT:
29136         jj_consume_token(AUDIT);
29137         break;
29138       case COMMENT:
29139         jj_consume_token(COMMENT);
29140         break;
29141       case CREATE:
29142         jj_consume_token(CREATE);
29143         break;
29144       case DISASSOCIATE:
29145         jj_consume_token(DISASSOCIATE);
29146         jj_consume_token(STATISTICS);
29147         break;
29148       case DROP:
29149         jj_consume_token(DROP);
29150         break;
29151       case GRANT:
29152         jj_consume_token(GRANT);
29153         break;
29154       case NOAUDIT:
29155         jj_consume_token(NOAUDIT);
29156         break;
29157       case RENAME:
29158         jj_consume_token(RENAME);
29159         break;
29160       case REVOKE:
29161         jj_consume_token(REVOKE);
29162         break;
29163       case TRUNCATE:
29164         jj_consume_token(TRUNCATE);
29165         break;
29166       case DDL:
29167         jj_consume_token(DDL);
29168         break;
29169       default:
29170         jj_la1[437] = jj_gen;
29171         jj_consume_token(-1);
29172         throw new ParseException();
29173       }
29174           jjtree.closeNodeScope(jjtn000, true);
29175           jjtc000 = false;
29176           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
29177     } finally {
29178     if (jjtc000) {
29179       jjtree.closeNodeScope(jjtn000, true);
29180     }
29181     }
29182     throw new Error("Missing return statement in function");
29183   }
29184 
29185   final public ASTDatabaseEvent DatabaseEvent() throws ParseException {
29186                                    /*@bgen(jjtree) DatabaseEvent */
29187   ASTDatabaseEvent jjtn000 = new ASTDatabaseEvent(this, JJTDATABASEEVENT);
29188   boolean jjtc000 = true;
29189   jjtree.openNodeScope(jjtn000);
29190     try {
29191       switch (jj_nt.kind) {
29192       case STARTUP:
29193         jj_consume_token(STARTUP);
29194         break;
29195       case SHUTDOWN:
29196         jj_consume_token(SHUTDOWN);
29197         break;
29198       case LOGON:
29199         jj_consume_token(LOGON);
29200         break;
29201       case LOGOFF:
29202         jj_consume_token(LOGOFF);
29203         break;
29204       case SERVERERROR:
29205         jj_consume_token(SERVERERROR);
29206         break;
29207       case SUSPEND:
29208         jj_consume_token(SUSPEND);
29209         break;
29210       default:
29211         jj_la1[438] = jj_gen;
29212         jj_consume_token(-1);
29213         throw new ParseException();
29214       }
29215           jjtree.closeNodeScope(jjtn000, true);
29216           jjtc000 = false;
29217           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
29218     } finally {
29219     if (jjtc000) {
29220       jjtree.closeNodeScope(jjtn000, true);
29221     }
29222     }
29223     throw new Error("Missing return statement in function");
29224   }
29225 
29226   final public ASTNonDMLEvent NonDMLEvent() throws ParseException {
29227                                /*@bgen(jjtree) NonDMLEvent */
29228   ASTNonDMLEvent jjtn000 = new ASTNonDMLEvent(this, JJTNONDMLEVENT);
29229   boolean jjtc000 = true;
29230   jjtree.openNodeScope(jjtn000);
29231     try {
29232       switch (jj_nt.kind) {
29233       case ALTER:
29234       case COMMENT:
29235       case CREATE:
29236       case DROP:
29237       case GRANT:
29238       case RENAME:
29239       case REVOKE:
29240       case ANALYZE:
29241       case ASSOCIATE:
29242       case AUDIT:
29243       case DDL:
29244       case DISASSOCIATE:
29245       case NOAUDIT:
29246       case TRUNCATE:
29247         DDLEvent();
29248         break;
29249       case LOGOFF:
29250       case LOGON:
29251       case SERVERERROR:
29252       case SHUTDOWN:
29253       case STARTUP:
29254       case SUSPEND:
29255         DatabaseEvent();
29256         break;
29257       default:
29258         jj_la1[439] = jj_gen;
29259         jj_consume_token(-1);
29260         throw new ParseException();
29261       }
29262     jjtree.closeNodeScope(jjtn000, true);
29263     jjtc000 = false;
29264     {if (true) return jjtn000;}
29265     } catch (Throwable jjte000) {
29266     if (jjtc000) {
29267       jjtree.clearNodeScope(jjtn000);
29268       jjtc000 = false;
29269     } else {
29270       jjtree.popNode();
29271     }
29272     if (jjte000 instanceof RuntimeException) {
29273       {if (true) throw (RuntimeException)jjte000;}
29274     }
29275     if (jjte000 instanceof ParseException) {
29276       {if (true) throw (ParseException)jjte000;}
29277     }
29278     {if (true) throw (Error)jjte000;}
29279     } finally {
29280     if (jjtc000) {
29281       jjtree.closeNodeScope(jjtn000, true);
29282     }
29283     }
29284     throw new Error("Missing return statement in function");
29285   }
29286 
29287 /*
29288 When DBMS_METADATA.GET_DDL returns a trigger, it can come in 2 DDL statements.
29289 The first is the CREATE OR REPLACE TRIGER statement; the second is an ALTER TRIGGER statement,
29290 enabling or disabling the trigger.
29291 
29292 Unlike the ALTER TYPE, it does not seem to alter the structure of the object.
29293 */
29294   final public void AlterTrigger() throws ParseException {
29295  /*@bgen(jjtree) AlterTrigger */
29296   ASTAlterTrigger jjtn000 = new ASTAlterTrigger(this, JJTALTERTRIGGER);
29297   boolean jjtc000 = true;
29298   jjtree.openNodeScope(jjtn000);
29299     try {
29300       jj_consume_token(ALTER);
29301       jj_consume_token(TRIGGER);
29302       Skip2NextTerminator(null,";");
29303       jj_consume_token(4);
29304           jjtree.closeNodeScope(jjtn000, true);
29305           jjtc000 = false;
29306                 {if (true) return;}
29307     } catch (Throwable jjte000) {
29308           if (jjtc000) {
29309             jjtree.clearNodeScope(jjtn000);
29310             jjtc000 = false;
29311           } else {
29312             jjtree.popNode();
29313           }
29314           if (jjte000 instanceof RuntimeException) {
29315             {if (true) throw (RuntimeException)jjte000;}
29316           }
29317           if (jjte000 instanceof ParseException) {
29318             {if (true) throw (ParseException)jjte000;}
29319           }
29320           {if (true) throw (Error)jjte000;}
29321     } finally {
29322           if (jjtc000) {
29323             jjtree.closeNodeScope(jjtn000, true);
29324           }
29325     }
29326   }
29327 
29328 //SRT 2011-04-17 - START 
29329   final public ASTKEYWORD_RESERVED KEYWORD_RESERVED() throws ParseException {
29330                                           /*@bgen(jjtree) KEYWORD_RESERVED */
29331   ASTKEYWORD_RESERVED jjtn000 = new ASTKEYWORD_RESERVED(this, JJTKEYWORD_RESERVED);
29332   boolean jjtc000 = true;
29333   jjtree.openNodeScope(jjtn000);
29334     try {
29335       switch (jj_nt.kind) {
29336       case ALL:
29337         jj_consume_token(ALL);
29338         break;
29339       case ALTER:
29340         jj_consume_token(ALTER);
29341         break;
29342       case AND:
29343         jj_consume_token(AND);
29344         break;
29345       case ANY:
29346         jj_consume_token(ANY);
29347         break;
29348       case AS:
29349         jj_consume_token(AS);
29350         break;
29351       case ASC:
29352         jj_consume_token(ASC);
29353         break;
29354       case BETWEEN:
29355         jj_consume_token(BETWEEN);
29356         break;
29357       case BY:
29358         jj_consume_token(BY);
29359         break;
29360       case CHAR:
29361         jj_consume_token(CHAR);
29362         break;
29363       case CHECK:
29364         jj_consume_token(CHECK);
29365         break;
29366       case CLUSTER:
29367         jj_consume_token(CLUSTER);
29368         break;
29369       case COMPRESS:
29370         jj_consume_token(COMPRESS);
29371         break;
29372       case CONNECT:
29373         jj_consume_token(CONNECT);
29374         break;
29375       case CREATE:
29376         jj_consume_token(CREATE);
29377         break;
29378       case DATE:
29379         jj_consume_token(DATE);
29380         break;
29381       case DECIMAL:
29382         jj_consume_token(DECIMAL);
29383         break;
29384       case _DEFAULT:
29385         jj_consume_token(_DEFAULT);
29386         break;
29387       case DELETE:
29388         jj_consume_token(DELETE);
29389         break;
29390       case DESC:
29391         jj_consume_token(DESC);
29392         break;
29393       case DISTINCT:
29394         jj_consume_token(DISTINCT);
29395         break;
29396       case DROP:
29397         jj_consume_token(DROP);
29398         break;
29399       case ELSE:
29400         jj_consume_token(ELSE);
29401         break;
29402       case EXCLUSIVE:
29403         jj_consume_token(EXCLUSIVE);
29404         break;
29405       case EXISTS:
29406         jj_consume_token(EXISTS);
29407         break;
29408       case FLOAT:
29409         jj_consume_token(FLOAT);
29410         break;
29411       case FOR:
29412         jj_consume_token(FOR);
29413         break;
29414       case FROM:
29415         jj_consume_token(FROM);
29416         break;
29417       case GRANT:
29418         jj_consume_token(GRANT);
29419         break;
29420       case GROUP:
29421         jj_consume_token(GROUP);
29422         break;
29423       case HAVING:
29424         jj_consume_token(HAVING);
29425         break;
29426       case IDENTIFIED:
29427         jj_consume_token(IDENTIFIED);
29428         break;
29429       case IN:
29430         jj_consume_token(IN);
29431         break;
29432       case INDEX:
29433         jj_consume_token(INDEX);
29434         break;
29435       case INSERT:
29436         jj_consume_token(INSERT);
29437         break;
29438       case INTEGER:
29439         jj_consume_token(INTEGER);
29440         break;
29441       case INTERSECT:
29442         jj_consume_token(INTERSECT);
29443         break;
29444       case INTO:
29445         jj_consume_token(INTO);
29446         break;
29447       case IS:
29448         jj_consume_token(IS);
29449         break;
29450       case LIKE:
29451         jj_consume_token(LIKE);
29452         break;
29453       case LOCK:
29454         jj_consume_token(LOCK);
29455         break;
29456       case LONG:
29457         jj_consume_token(LONG);
29458         break;
29459       case MINUS:
29460         jj_consume_token(MINUS);
29461         break;
29462       case MODE:
29463         jj_consume_token(MODE);
29464         break;
29465       case NOCOMPRESS:
29466         jj_consume_token(NOCOMPRESS);
29467         break;
29468       case NOT:
29469         jj_consume_token(NOT);
29470         break;
29471       case NOWAIT:
29472         jj_consume_token(NOWAIT);
29473         break;
29474       case NULL:
29475         jj_consume_token(NULL);
29476         break;
29477       case NUMBER:
29478         jj_consume_token(NUMBER);
29479         break;
29480       case OF:
29481         jj_consume_token(OF);
29482         break;
29483       case ON:
29484         jj_consume_token(ON);
29485         break;
29486       case OPTION:
29487         jj_consume_token(OPTION);
29488         break;
29489       case OR:
29490         jj_consume_token(OR);
29491         break;
29492       case ORDER:
29493         jj_consume_token(ORDER);
29494         break;
29495       case PCTFREE:
29496         jj_consume_token(PCTFREE);
29497         break;
29498       case PRIOR:
29499         jj_consume_token(PRIOR);
29500         break;
29501       case PUBLIC:
29502         jj_consume_token(PUBLIC);
29503         break;
29504       case RAW:
29505         jj_consume_token(RAW);
29506         break;
29507       case RESOURCE:
29508         jj_consume_token(RESOURCE);
29509         break;
29510       case REVOKE:
29511         jj_consume_token(REVOKE);
29512         break;
29513       case SELECT:
29514         jj_consume_token(SELECT);
29515         break;
29516       case SET:
29517         jj_consume_token(SET);
29518         break;
29519       case SHARE:
29520         jj_consume_token(SHARE);
29521         break;
29522       case SIZE:
29523         jj_consume_token(SIZE);
29524         break;
29525       case SMALLINT:
29526         jj_consume_token(SMALLINT);
29527         break;
29528       case START:
29529         jj_consume_token(START);
29530         break;
29531       case SYNONYM:
29532         jj_consume_token(SYNONYM);
29533         break;
29534       case TABLE:
29535         jj_consume_token(TABLE);
29536         break;
29537       case THEN:
29538         jj_consume_token(THEN);
29539         break;
29540       case TO:
29541         jj_consume_token(TO);
29542         break;
29543       case TRIGGER:
29544         jj_consume_token(TRIGGER);
29545         break;
29546       case UNION:
29547         jj_consume_token(UNION);
29548         break;
29549       case UNIQUE:
29550         jj_consume_token(UNIQUE);
29551         break;
29552       case UPDATE:
29553         jj_consume_token(UPDATE);
29554         break;
29555       case VALUES:
29556         jj_consume_token(VALUES);
29557         break;
29558       case VARCHAR:
29559         jj_consume_token(VARCHAR);
29560         break;
29561       case VARCHAR2:
29562         jj_consume_token(VARCHAR2);
29563         break;
29564       case VIEW:
29565         jj_consume_token(VIEW);
29566         break;
29567       case WHERE:
29568         jj_consume_token(WHERE);
29569         break;
29570       case WITH:
29571         jj_consume_token(WITH);
29572         break;
29573       default:
29574         jj_la1[440] = jj_gen;
29575         jj_consume_token(-1);
29576         throw new ParseException();
29577       }
29578    jjtree.closeNodeScope(jjtn000, true);
29579    jjtc000 = false;
29580    jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
29581     } finally {
29582   if (jjtc000) {
29583     jjtree.closeNodeScope(jjtn000, true);
29584   }
29585     }
29586     throw new Error("Missing return statement in function");
29587   }
29588 
29589   final public ASTKEYWORD_UNRESERVED KEYWORD_UNRESERVED() throws ParseException {
29590                                               /*@bgen(jjtree) KEYWORD_UNRESERVED */
29591   ASTKEYWORD_UNRESERVED jjtn000 = new ASTKEYWORD_UNRESERVED(this, JJTKEYWORD_UNRESERVED);
29592   boolean jjtc000 = true;
29593   jjtree.openNodeScope(jjtn000);
29594     try {
29595       switch (jj_nt.kind) {
29596       case FALSE:
29597         jj_consume_token(FALSE);
29598         break;
29599       case TRUE:
29600         jj_consume_token(TRUE);
29601         break;
29602       case A:
29603         jj_consume_token(A);
29604         break;
29605       case ACCEPT:
29606         jj_consume_token(ACCEPT);
29607         break;
29608       case ADD:
29609         jj_consume_token(ADD);
29610         break;
29611       case AFTER:
29612         jj_consume_token(AFTER);
29613         break;
29614       case AGGREGATE:
29615         jj_consume_token(AGGREGATE);
29616         break;
29617       case ANALYZE:
29618         jj_consume_token(ANALYZE);
29619         break;
29620       case ASSOCIATE:
29621         jj_consume_token(ASSOCIATE);
29622         break;
29623       case AT:
29624         jj_consume_token(AT);
29625         break;
29626       case ATTACH:
29627         jj_consume_token(ATTACH);
29628         break;
29629       case ATTRIBUTE:
29630         jj_consume_token(ATTRIBUTE);
29631         break;
29632       case AUDIT:
29633         jj_consume_token(AUDIT);
29634         break;
29635       case AUTHENTICATED:
29636         jj_consume_token(AUTHENTICATED);
29637         break;
29638       case AUTHID:
29639         jj_consume_token(AUTHID);
29640         break;
29641       case BEFORE:
29642         jj_consume_token(BEFORE);
29643         break;
29644       case BFILE:
29645         jj_consume_token(BFILE);
29646         break;
29647       case BLOB:
29648         jj_consume_token(BLOB);
29649         break;
29650       case BOTH:
29651         jj_consume_token(BOTH);
29652         break;
29653       case BULK:
29654         jj_consume_token(BULK);
29655         break;
29656       case BYTE:
29657         jj_consume_token(BYTE);
29658         break;
29659       case CALL:
29660         jj_consume_token(CALL);
29661         break;
29662       case CASCADE:
29663         jj_consume_token(CASCADE);
29664         break;
29665       case CAST:
29666         jj_consume_token(CAST);
29667         break;
29668       case CHAR_CS:
29669         jj_consume_token(CHAR_CS);
29670         break;
29671       case CHARACTER:
29672         jj_consume_token(CHARACTER);
29673         break;
29674       case CHARSETFORM:
29675         jj_consume_token(CHARSETFORM);
29676         break;
29677       case CHARSETID:
29678         jj_consume_token(CHARSETID);
29679         break;
29680       case CLOB:
29681         jj_consume_token(CLOB);
29682         break;
29683       case CLOSE:
29684         jj_consume_token(CLOSE);
29685         break;
29686       case COALESCE:
29687         jj_consume_token(COALESCE);
29688         break;
29689       case COLLECT:
29690         jj_consume_token(COLLECT);
29691         break;
29692       case COLUMN:
29693         jj_consume_token(COLUMN);
29694         break;
29695       case COMMENT:
29696         jj_consume_token(COMMENT);
29697         break;
29698       case COMMIT:
29699         jj_consume_token(COMMIT);
29700         break;
29701       case COMPOUND:
29702         jj_consume_token(COMPOUND);
29703         break;
29704       case CONSTRUCTOR:
29705         jj_consume_token(CONSTRUCTOR);
29706         break;
29707       case CONTEXT:
29708         jj_consume_token(CONTEXT);
29709         break;
29710       case CONTINUE:
29711         jj_consume_token(CONTINUE);
29712         break;
29713       case CONVERT:
29714         jj_consume_token(CONVERT);
29715         break;
29716       case COPY:
29717         jj_consume_token(COPY);
29718         break;
29719       case CURRENT:
29720         jj_consume_token(CURRENT);
29721         break;
29722       case CURRENT_USER:
29723         jj_consume_token(CURRENT_USER);
29724         break;
29725       case CURSOR:
29726         jj_consume_token(CURSOR);
29727         break;
29728       case DATA:
29729         jj_consume_token(DATA);
29730         break;
29731       case DATABASE:
29732         jj_consume_token(DATABASE);
29733         break;
29734       case DAY:
29735         jj_consume_token(DAY);
29736         break;
29737       case DBTIMEZONE:
29738         jj_consume_token(DBTIMEZONE);
29739         break;
29740       case DDL:
29741         jj_consume_token(DDL);
29742         break;
29743       case DEC:
29744         jj_consume_token(DEC);
29745         break;
29746       case DEFINE:
29747         jj_consume_token(DEFINE);
29748         break;
29749       case DEFINER:
29750         jj_consume_token(DEFINER);
29751         break;
29752       case DIRECTORY:
29753         jj_consume_token(DIRECTORY);
29754         break;
29755       case DISABLE:
29756         jj_consume_token(DISABLE);
29757         break;
29758       case DISASSOCIATE:
29759         jj_consume_token(DISASSOCIATE);
29760         break;
29761       case DISCONNECT:
29762         jj_consume_token(DISCONNECT);
29763         break;
29764       case DOUBLE:
29765         jj_consume_token(DOUBLE);
29766         break;
29767       case EACH:
29768         jj_consume_token(EACH);
29769         break;
29770       case ELEMENT:
29771         jj_consume_token(ELEMENT);
29772         break;
29773       case EMPTY:
29774         jj_consume_token(EMPTY);
29775         break;
29776       case ENABLE:
29777         jj_consume_token(ENABLE);
29778         break;
29779       case ESCAPE:
29780         jj_consume_token(ESCAPE);
29781         break;
29782       case EXCEPT:
29783         jj_consume_token(EXCEPT);
29784         break;
29785       case EXCEPTIONS:
29786         jj_consume_token(EXCEPTIONS);
29787         break;
29788       case EXIT:
29789         jj_consume_token(EXIT);
29790         break;
29791       case EXTENDS:
29792         jj_consume_token(EXTENDS);
29793         break;
29794       case EXTERNAL:
29795         jj_consume_token(EXTERNAL);
29796         break;
29797       case EXTRACT:
29798         jj_consume_token(EXTRACT);
29799         break;
29800       case FINAL:
29801         jj_consume_token(FINAL);
29802         break;
29803       case FOLLOWS:
29804         jj_consume_token(FOLLOWS);
29805         break;
29806       case FORCE:
29807         jj_consume_token(FORCE);
29808         break;
29809       case FUNCTION:
29810         jj_consume_token(FUNCTION);
29811         break;
29812       case GLOBAL:
29813         jj_consume_token(GLOBAL);
29814         break;
29815       case HASH:
29816         jj_consume_token(HASH);
29817         break;
29818       case HEAP:
29819         jj_consume_token(HEAP);
29820         break;
29821       case HOST:
29822         jj_consume_token(HOST);
29823         break;
29824       case HOUR:
29825         jj_consume_token(HOUR);
29826         break;
29827       case IMMEDIATE:
29828         jj_consume_token(IMMEDIATE);
29829         break;
29830       case INDEXTYPE:
29831         jj_consume_token(INDEXTYPE);
29832         break;
29833       case INDICATOR:
29834         jj_consume_token(INDICATOR);
29835         break;
29836       case INDICES:
29837         jj_consume_token(INDICES);
29838         break;
29839       case INSTANTIABLE:
29840         jj_consume_token(INSTANTIABLE);
29841         break;
29842       case INTERVAL:
29843         jj_consume_token(INTERVAL);
29844         break;
29845       case INVALIDATE:
29846         jj_consume_token(INVALIDATE);
29847         break;
29848       case ISOLATION:
29849         jj_consume_token(ISOLATION);
29850         break;
29851       case JAVA:
29852         jj_consume_token(JAVA);
29853         break;
29854       case LANGUAGE:
29855         jj_consume_token(LANGUAGE);
29856         break;
29857       case LEADING:
29858         jj_consume_token(LEADING);
29859         break;
29860       case LEFT:
29861         jj_consume_token(LEFT);
29862         break;
29863       case LENGTH:
29864         jj_consume_token(LENGTH);
29865         break;
29866       case LEVEL:
29867         jj_consume_token(LEVEL);
29868         break;
29869       case LIBRARY:
29870         jj_consume_token(LIBRARY);
29871         break;
29872       case LIMIT:
29873         jj_consume_token(LIMIT);
29874         break;
29875       case LINK:
29876         jj_consume_token(LINK);
29877         break;
29878       case LOCAL:
29879         jj_consume_token(LOCAL);
29880         break;
29881       case LOGOFF:
29882         jj_consume_token(LOGOFF);
29883         break;
29884       case LOGON:
29885         jj_consume_token(LOGON);
29886         break;
29887       case MAP:
29888         jj_consume_token(MAP);
29889         break;
29890       case MAX:
29891         jj_consume_token(MAX);
29892         break;
29893       case MAXLEN:
29894         jj_consume_token(MAXLEN);
29895         break;
29896       case MEMBER:
29897         jj_consume_token(MEMBER);
29898         break;
29899       case MERGE:
29900         jj_consume_token(MERGE);
29901         break;
29902       case MIN:
29903         jj_consume_token(MIN);
29904         break;
29905       case MINUTE:
29906         jj_consume_token(MINUTE);
29907         break;
29908       case MLSLABEL:
29909         jj_consume_token(MLSLABEL);
29910         break;
29911       case MODIFY:
29912         jj_consume_token(MODIFY);
29913         break;
29914       case MONTH:
29915         jj_consume_token(MONTH);
29916         break;
29917       case MULTISET:
29918         jj_consume_token(MULTISET);
29919         break;
29920       case NAME:
29921         jj_consume_token(NAME);
29922         break;
29923       case NATURAL:
29924         jj_consume_token(NATURAL);
29925         break;
29926       case NCHAR:
29927         jj_consume_token(NCHAR);
29928         break;
29929       case NCHAR_CS:
29930         jj_consume_token(NCHAR_CS);
29931         break;
29932       case NCLOB:
29933         jj_consume_token(NCLOB);
29934         break;
29935       case NESTED:
29936         jj_consume_token(NESTED);
29937         break;
29938       case NEW:
29939         jj_consume_token(NEW);
29940         break;
29941       case NO:
29942         jj_consume_token(NO);
29943         break;
29944       case NOAUDIT:
29945         jj_consume_token(NOAUDIT);
29946         break;
29947       case NUMERIC:
29948         jj_consume_token(NUMERIC);
29949         break;
29950       case NVARCHAR2:
29951         jj_consume_token(NVARCHAR2);
29952         break;
29953       case OBJECT:
29954         jj_consume_token(OBJECT);
29955         break;
29956       case OID:
29957         jj_consume_token(OID);
29958         break;
29959       case OLD:
29960         jj_consume_token(OLD);
29961         break;
29962       case OPAQUE:
29963         jj_consume_token(OPAQUE);
29964         break;
29965       case OPEN:
29966         jj_consume_token(OPEN);
29967         break;
29968       case ORGANIZATION:
29969         jj_consume_token(ORGANIZATION);
29970         break;
29971       case OTHERS:
29972         jj_consume_token(OTHERS);
29973         break;
29974       case OVERRIDING:
29975         jj_consume_token(OVERRIDING);
29976         break;
29977       case PACKAGE:
29978         jj_consume_token(PACKAGE);
29979         break;
29980       case PARAMETERS:
29981         jj_consume_token(PARAMETERS);
29982         break;
29983       case PARENT:
29984         jj_consume_token(PARENT);
29985         break;
29986       case PARTITION:
29987         jj_consume_token(PARTITION);
29988         break;
29989       case PRECISION:
29990         jj_consume_token(PRECISION);
29991         break;
29992       case PRESERVE:
29993         jj_consume_token(PRESERVE);
29994         break;
29995       case PRINT:
29996         jj_consume_token(PRINT);
29997         break;
29998       case PROCEDURE:
29999         jj_consume_token(PROCEDURE);
30000         break;
30001       case QUIT:
30002         jj_consume_token(QUIT);
30003         break;
30004       case RANGE:
30005         jj_consume_token(RANGE);
30006         break;
30007       case REAL:
30008         jj_consume_token(REAL);
30009         break;
30010       case RECORD:
30011         jj_consume_token(RECORD);
30012         break;
30013       case REF:
30014         jj_consume_token(REF);
30015         break;
30016       case RELIES_ON:
30017         jj_consume_token(RELIES_ON);
30018         break;
30019       case REMARK:
30020         jj_consume_token(REMARK);
30021         break;
30022       case RESULT:
30023         jj_consume_token(RESULT);
30024         break;
30025       case RETURN:
30026         jj_consume_token(RETURN);
30027         break;
30028       case RETURNING:
30029         jj_consume_token(RETURNING);
30030         break;
30031       case REVERSE:
30032         jj_consume_token(REVERSE);
30033         break;
30034       case RIGHT:
30035         jj_consume_token(RIGHT);
30036         break;
30037       case ROLLBACK:
30038         jj_consume_token(ROLLBACK);
30039         break;
30040       case ROW:
30041         jj_consume_token(ROW);
30042         break;
30043       case ROWID:
30044         jj_consume_token(ROWID);
30045         break;
30046       case ROWNUM:
30047         jj_consume_token(ROWNUM);
30048         break;
30049       case ROWS:
30050         jj_consume_token(ROWS);
30051         break;
30052       case SAVE:
30053         jj_consume_token(SAVE);
30054         break;
30055       case SAVEPOINT:
30056         jj_consume_token(SAVEPOINT);
30057         break;
30058       case SCHEMA:
30059         jj_consume_token(SCHEMA);
30060         break;
30061       case SECOND:
30062         jj_consume_token(SECOND);
30063         break;
30064       case SELF:
30065         jj_consume_token(SELF);
30066         break;
30067       case SERVERERROR:
30068         jj_consume_token(SERVERERROR);
30069         break;
30070       case SESSIONTIMEZONE:
30071         jj_consume_token(SESSIONTIMEZONE);
30072         break;
30073       case SET:
30074         jj_consume_token(SET);
30075         break;
30076       case SHARED:
30077         jj_consume_token(SHARED);
30078         break;
30079       case SHUTDOWN:
30080         jj_consume_token(SHUTDOWN);
30081         break;
30082       case SPACE:
30083         jj_consume_token(SPACE);
30084         break;
30085       case STARTUP:
30086         jj_consume_token(STARTUP);
30087         break;
30088       case STATEMENT:
30089         jj_consume_token(STATEMENT);
30090         break;
30091       case STATIC:
30092         jj_consume_token(STATIC);
30093         break;
30094       case STATISTICS:
30095         jj_consume_token(STATISTICS);
30096         break;
30097       case STRUCT:
30098         jj_consume_token(STRUCT);
30099         break;
30100       case SUBMULTISET:
30101         jj_consume_token(SUBMULTISET);
30102         break;
30103       case SUBSTITUTABLE:
30104         jj_consume_token(SUBSTITUTABLE);
30105         break;
30106       case SUBTYPE:
30107         jj_consume_token(SUBTYPE);
30108         break;
30109       case SUCCESSFUL:
30110         jj_consume_token(SUCCESSFUL);
30111         break;
30112       case SUSPEND:
30113         jj_consume_token(SUSPEND);
30114         break;
30115       case TDO:
30116         jj_consume_token(TDO);
30117         break;
30118       case TEMPORARY:
30119         jj_consume_token(TEMPORARY);
30120         break;
30121       case TIME:
30122         jj_consume_token(TIME);
30123         break;
30124       case TIMESTAMP:
30125         jj_consume_token(TIMESTAMP);
30126         break;
30127       case TIMEZONE_ABBR:
30128         jj_consume_token(TIMEZONE_ABBR);
30129         break;
30130       case TIMEZONE_HOUR:
30131         jj_consume_token(TIMEZONE_HOUR);
30132         break;
30133       case TIMEZONE_MINUTE:
30134         jj_consume_token(TIMEZONE_MINUTE);
30135         break;
30136       case TIMEZONE_REGION:
30137         jj_consume_token(TIMEZONE_REGION);
30138         break;
30139       case TRAILING:
30140         jj_consume_token(TRAILING);
30141         break;
30142       case TRANSACTION:
30143         jj_consume_token(TRANSACTION);
30144         break;
30145       case TREAT:
30146         jj_consume_token(TREAT);
30147         break;
30148       case TRIM:
30149         jj_consume_token(TRIM);
30150         break;
30151       case TRUNCATE:
30152         jj_consume_token(TRUNCATE);
30153         break;
30154       case UNDEFINE:
30155         jj_consume_token(UNDEFINE);
30156         break;
30157       case UNDER:
30158         jj_consume_token(UNDER);
30159         break;
30160       case UROWID:
30161         jj_consume_token(UROWID);
30162         break;
30163       case USER:
30164         jj_consume_token(USER);
30165         break;
30166       case USING:
30167         jj_consume_token(USING);
30168         break;
30169       case VARRAY:
30170         jj_consume_token(VARRAY);
30171         break;
30172       case VARIABLE:
30173         jj_consume_token(VARIABLE);
30174         break;
30175       case VARYING:
30176         jj_consume_token(VARYING);
30177         break;
30178       case WHENEVER:
30179         jj_consume_token(WHENEVER);
30180         break;
30181       case YEAR:
30182         jj_consume_token(YEAR);
30183         break;
30184       case YES:
30185         jj_consume_token(YES);
30186         break;
30187       case ZONE:
30188         jj_consume_token(ZONE);
30189         break;
30190       case SHOW:
30191         jj_consume_token(SHOW);
30192         break;
30193       case WRAPPED:
30194         jj_consume_token(WRAPPED);
30195         break;
30196       case SYS_REFCURSOR:
30197         jj_consume_token(SYS_REFCURSOR);
30198         break;
30199       case EDITIONABLE:
30200         jj_consume_token(EDITIONABLE);
30201         break;
30202       case NONEDITIONABLE:
30203         jj_consume_token(NONEDITIONABLE);
30204         break;
30205       case ACCESSIBLE:
30206         jj_consume_token(ACCESSIBLE);
30207         break;
30208       case NULLIF:
30209         jj_consume_token(NULLIF);
30210         break;
30211       case RENAME:
30212         jj_consume_token(RENAME);
30213         break;
30214       case RELEASE:
30215         jj_consume_token(RELEASE);
30216         break;
30217       default:
30218         jj_la1[441] = jj_gen;
30219         jj_consume_token(-1);
30220         throw new ParseException();
30221       }
30222   jjtree.closeNodeScope(jjtn000, true);
30223   jjtc000 = false;
30224   jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
30225     } finally {
30226   if (jjtc000) {
30227     jjtree.closeNodeScope(jjtn000, true);
30228   }
30229     }
30230     throw new Error("Missing return statement in function");
30231   }
30232 
30233 //SRT 2011-04-17 - END  */
30234 /**
30235  * 2006-05-20 - Matthias Hendler - added <OLD> and <PARENT>  
30236  */
30237   final public ASTID ID() throws ParseException {
30238              /*@bgen(jjtree) ID */
30239   ASTID jjtn000 = new ASTID(this, JJTID);
30240   boolean jjtc000 = true;
30241   jjtree.openNodeScope(jjtn000);
30242     try {
30243       switch (jj_nt.kind) {
30244       case IDENTIFIER:
30245         jj_consume_token(IDENTIFIER);
30246         break;
30247       case QUOTED_LITERAL:
30248         jj_consume_token(QUOTED_LITERAL);
30249         break;
30250       case DEFINER:
30251       case CURRENT_USER:
30252       case LANGUAGE:
30253       case ADD:
30254       case AGGREGATE:
30255       case AT:
30256       case ATTRIBUTE:
30257       case AUTHID:
30258       case BULK:
30259       case BYTE:
30260       case CASCADE:
30261       case CLOSE:
30262       case COALESCE:
30263       case COLLECT:
30264       case COLUMN:
30265       case COMMENT:
30266       case COMMIT:
30267       case CONSTRUCTOR:
30268       case CONTINUE:
30269       case CONVERT:
30270       case CURRENT:
30271       case CURSOR:
30272       case DATA:
30273       case DAY:
30274       case DISABLE:
30275       case EDITIONABLE:
30276       case ELEMENT:
30277       case ENABLE:
30278       case ESCAPE:
30279       case EXCEPT:
30280       case EXCEPTIONS:
30281       case EXIT:
30282       case EXTERNAL:
30283       case EXTENDS:
30284       case EXTRACT:
30285       case FALSE:
30286       case FINAL:
30287       case FORCE:
30288       case FUNCTION:
30289       case GLOBAL:
30290       case HASH:
30291       case HEAP:
30292       case HOUR:
30293       case IMMEDIATE:
30294       case INDICES:
30295       case INDEXTYPE:
30296       case INDICATOR:
30297       case INSTANTIABLE:
30298       case INTERVAL:
30299       case INVALIDATE:
30300       case ISOLATION:
30301       case JAVA:
30302       case LEVEL:
30303       case LIMIT:
30304       case MAP:
30305       case MAX:
30306       case MEMBER:
30307       case MERGE:
30308       case MIN:
30309       case MINUTE:
30310       case MLSLABEL:
30311       case MODIFY:
30312       case MONTH:
30313       case NATURAL:
30314       case NEW:
30315       case NO:
30316       case NONEDITIONABLE:
30317       case NULLIF:
30318       case OBJECT:
30319       case OID:
30320       case OPAQUE:
30321       case OPEN:
30322       case ORGANIZATION:
30323       case OTHERS:
30324       case OVERRIDING:
30325       case PACKAGE:
30326       case PARTITION:
30327       case PRESERVE:
30328       case PROCEDURE:
30329       case RANGE:
30330       case REAL:
30331       case RECORD:
30332       case REF:
30333       case RELEASE:
30334       case RELIES_ON:
30335       case RENAME:
30336       case RESULT:
30337       case RETURN:
30338       case RETURNING:
30339       case REVERSE:
30340       case ROLLBACK:
30341       case ROW:
30342       case ROWS:
30343       case ROWID:
30344       case ROWNUM:
30345       case SAVE:
30346       case SAVEPOINT:
30347       case SECOND:
30348       case SELF:
30349       case SET:
30350       case SPACE:
30351       case STATIC:
30352       case SUBTYPE:
30353       case SUBSTITUTABLE:
30354       case SUCCESSFUL:
30355       case SYS_REFCURSOR:
30356       case TEMPORARY:
30357       case TIME:
30358       case TIMESTAMP:
30359       case TIMEZONE_REGION:
30360       case TIMEZONE_ABBR:
30361       case TIMEZONE_MINUTE:
30362       case TIMEZONE_HOUR:
30363       case TRANSACTION:
30364       case TRUE:
30365       case UNDER:
30366       case USING:
30367       case YES:
30368       case SHOW:
30369       case A:
30370       case DOUBLE:
30371       case DEC:
30372       case PRECISION:
30373       case NUMERIC:
30374       case NCHAR:
30375       case NVARCHAR2:
30376       case UROWID:
30377       case VARRAY:
30378       case VARYING:
30379       case BFILE:
30380       case BLOB:
30381       case CLOB:
30382       case NCLOB:
30383       case YEAR:
30384       case LOCAL:
30385       case ZONE:
30386       case CHARACTER:
30387       case AFTER:
30388       case BEFORE:
30389       case OLD:
30390       case PARENT:
30391       case ANALYZE:
30392       case ASSOCIATE:
30393       case AUDIT:
30394       case COMPOUND:
30395       case DATABASE:
30396       case CALL:
30397       case DDL:
30398       case DISASSOCIATE:
30399       case EACH:
30400       case FOLLOWS:
30401       case LOGOFF:
30402       case LOGON:
30403       case NESTED:
30404       case NOAUDIT:
30405       case SCHEMA:
30406       case SERVERERROR:
30407       case SHUTDOWN:
30408       case STARTUP:
30409       case STATEMENT:
30410       case STATISTICS:
30411       case SUSPEND:
30412       case TRUNCATE:
30413       case WRAPPED:
30414       case LIBRARY:
30415       case NAME:
30416       case STRUCT:
30417       case CONTEXT:
30418       case PARAMETERS:
30419       case LENGTH:
30420       case TDO:
30421       case MAXLEN:
30422       case CHARSETID:
30423       case CHARSETFORM:
30424       case ACCEPT:
30425       case ACCESSIBLE:
30426       case COPY:
30427       case DEFINE:
30428       case DISCONNECT:
30429       case HOST:
30430       case PRINT:
30431       case QUIT:
30432       case REMARK:
30433       case UNDEFINE:
30434       case VARIABLE:
30435       case WHENEVER:
30436       case ATTACH:
30437       case CAST:
30438       case TREAT:
30439       case TRIM:
30440       case LEFT:
30441       case RIGHT:
30442       case BOTH:
30443       case EMPTY:
30444       case MULTISET:
30445       case SUBMULTISET:
30446       case LEADING:
30447       case TRAILING:
30448       case CHAR_CS:
30449       case NCHAR_CS:
30450       case DBTIMEZONE:
30451       case SESSIONTIMEZONE:
30452       case AUTHENTICATED:
30453       case LINK:
30454       case SHARED:
30455       case DIRECTORY:
30456       case USER:
30457         KEYWORD_UNRESERVED();
30458         break;
30459       case REPLACE:
30460         jj_consume_token(REPLACE);
30461         break;
30462       case SERIALLY_REUSABLE:
30463         jj_consume_token(SERIALLY_REUSABLE);
30464         break;
30465       case RESTRICT_REFERENCES:
30466         jj_consume_token(RESTRICT_REFERENCES);
30467         break;
30468       case EXCEPTION_INIT:
30469         jj_consume_token(EXCEPTION_INIT);
30470         break;
30471       case AUTONOMOUS_TRANSACTION:
30472         jj_consume_token(AUTONOMOUS_TRANSACTION);
30473         break;
30474       case ALL:
30475         jj_consume_token(ALL);
30476         break;
30477       case ALTER:
30478         jj_consume_token(ALTER);
30479         break;
30480       case AND:
30481         jj_consume_token(AND);
30482         break;
30483       case ANY:
30484         jj_consume_token(ANY);
30485         break;
30486       case ARRAY:
30487         jj_consume_token(ARRAY);
30488         break;
30489       case AS:
30490         jj_consume_token(AS);
30491         break;
30492       case ASC:
30493         jj_consume_token(ASC);
30494         break;
30495       case AVG:
30496         jj_consume_token(AVG);
30497         break;
30498       case BETWEEN:
30499         jj_consume_token(BETWEEN);
30500         break;
30501       case BINARY_INTEGER:
30502         jj_consume_token(BINARY_INTEGER);
30503         break;
30504       case BODY:
30505         jj_consume_token(BODY);
30506         break;
30507       case BOOLEAN:
30508         jj_consume_token(BOOLEAN);
30509         break;
30510       case BY:
30511         jj_consume_token(BY);
30512         break;
30513       case CASE:
30514         jj_consume_token(CASE);
30515         break;
30516       case CHAR:
30517         jj_consume_token(CHAR);
30518         break;
30519       case CHAR_BASE:
30520         jj_consume_token(CHAR_BASE);
30521         break;
30522       case CHECK:
30523         jj_consume_token(CHECK);
30524         break;
30525       case CLUSTER:
30526         jj_consume_token(CLUSTER);
30527         break;
30528       case COMPRESS:
30529         jj_consume_token(COMPRESS);
30530         break;
30531       case CONNECT:
30532         jj_consume_token(CONNECT);
30533         break;
30534       case CONSTANT:
30535         jj_consume_token(CONSTANT);
30536         break;
30537       case CREATE:
30538         jj_consume_token(CREATE);
30539         break;
30540       case CURRVAL:
30541         jj_consume_token(CURRVAL);
30542         break;
30543       case DATE:
30544         jj_consume_token(DATE);
30545         break;
30546       case DECLARE:
30547         jj_consume_token(DECLARE);
30548         break;
30549       case DECIMAL:
30550         jj_consume_token(DECIMAL);
30551         break;
30552       case _DEFAULT:
30553         jj_consume_token(_DEFAULT);
30554         break;
30555       case DELETE:
30556         jj_consume_token(DELETE);
30557         break;
30558       case DESC:
30559         jj_consume_token(DESC);
30560         break;
30561       case DISTINCT:
30562         jj_consume_token(DISTINCT);
30563         break;
30564       case DO:
30565         jj_consume_token(DO);
30566         break;
30567       case DROP:
30568         jj_consume_token(DROP);
30569         break;
30570       case ELSE:
30571         jj_consume_token(ELSE);
30572         break;
30573       case ELSIF:
30574         jj_consume_token(ELSIF);
30575         break;
30576       case EXCEPTION:
30577         jj_consume_token(EXCEPTION);
30578         break;
30579       case EXCLUSIVE:
30580         jj_consume_token(EXCLUSIVE);
30581         break;
30582       case EXECUTE:
30583         jj_consume_token(EXECUTE);
30584         break;
30585       case EXISTS:
30586         jj_consume_token(EXISTS);
30587         break;
30588       case FETCH:
30589         jj_consume_token(FETCH);
30590         break;
30591       case FLOAT:
30592         jj_consume_token(FLOAT);
30593         break;
30594       case FOR:
30595         jj_consume_token(FOR);
30596         break;
30597       case FORALL:
30598         jj_consume_token(FORALL);
30599         break;
30600       case FROM:
30601         jj_consume_token(FROM);
30602         break;
30603       case GOTO:
30604         jj_consume_token(GOTO);
30605         break;
30606       case GROUP:
30607         jj_consume_token(GROUP);
30608         break;
30609       case HAVING:
30610         jj_consume_token(HAVING);
30611         break;
30612       case IF:
30613         jj_consume_token(IF);
30614         break;
30615       case IN:
30616         jj_consume_token(IN);
30617         break;
30618       case INDEX:
30619         jj_consume_token(INDEX);
30620         break;
30621       case INSERT:
30622         jj_consume_token(INSERT);
30623         break;
30624       case INTEGER:
30625         jj_consume_token(INTEGER);
30626         break;
30627       case INTERFACE:
30628         jj_consume_token(INTERFACE);
30629         break;
30630       case INTERSECT:
30631         jj_consume_token(INTERSECT);
30632         break;
30633       case INTO:
30634         jj_consume_token(INTO);
30635         break;
30636       case IS:
30637         jj_consume_token(IS);
30638         break;
30639       case LIKE:
30640         jj_consume_token(LIKE);
30641         break;
30642       case LIMITED:
30643         jj_consume_token(LIMITED);
30644         break;
30645       case LOCK:
30646         jj_consume_token(LOCK);
30647         break;
30648       case LONG:
30649         jj_consume_token(LONG);
30650         break;
30651       case LOOP:
30652         jj_consume_token(LOOP);
30653         break;
30654       case MINUS:
30655         jj_consume_token(MINUS);
30656         break;
30657       case MOD:
30658         jj_consume_token(MOD);
30659         break;
30660       case MODE:
30661         jj_consume_token(MODE);
30662         break;
30663       case NATURALN:
30664         jj_consume_token(NATURALN);
30665         break;
30666       case NEXTVAL:
30667         jj_consume_token(NEXTVAL);
30668         break;
30669       case NOCOPY:
30670         jj_consume_token(NOCOPY);
30671         break;
30672       case NOT:
30673         jj_consume_token(NOT);
30674         break;
30675       case NOWAIT:
30676         jj_consume_token(NOWAIT);
30677         break;
30678       case NULL:
30679         jj_consume_token(NULL);
30680         break;
30681       case NUMBER:
30682         jj_consume_token(NUMBER);
30683         break;
30684       case NUMBER_BASE:
30685         jj_consume_token(NUMBER_BASE);
30686         break;
30687       case OCIROWID:
30688         jj_consume_token(OCIROWID);
30689         break;
30690       case OF:
30691         jj_consume_token(OF);
30692         break;
30693       case ON:
30694         jj_consume_token(ON);
30695         break;
30696       case BFILE_BASE:
30697         jj_consume_token(BFILE_BASE);
30698         break;
30699       case BLOB_BASE:
30700         jj_consume_token(BLOB_BASE);
30701         break;
30702       case CLOB_BASE:
30703         jj_consume_token(CLOB_BASE);
30704         break;
30705       case DATE_BASE:
30706         jj_consume_token(DATE_BASE);
30707         break;
30708       case OPERATOR:
30709         jj_consume_token(OPERATOR);
30710         break;
30711       case OPTION:
30712         jj_consume_token(OPTION);
30713         break;
30714       case OR:
30715         jj_consume_token(OR);
30716         break;
30717       case ORDER:
30718         jj_consume_token(ORDER);
30719         break;
30720       case OUT:
30721         jj_consume_token(OUT);
30722         break;
30723       case PCTFREE:
30724         jj_consume_token(PCTFREE);
30725         break;
30726       case PLS_INTEGER:
30727         jj_consume_token(PLS_INTEGER);
30728         break;
30729       case POSITIVE:
30730         jj_consume_token(POSITIVE);
30731         break;
30732       case POSITIVEN:
30733         jj_consume_token(POSITIVEN);
30734         break;
30735       case PRIOR:
30736         jj_consume_token(PRIOR);
30737         break;
30738       case PRIVATE:
30739         jj_consume_token(PRIVATE);
30740         break;
30741       case PROMPT:
30742         jj_consume_token(PROMPT);
30743         break;
30744       case PUBLIC:
30745         jj_consume_token(PUBLIC);
30746         break;
30747       case RAISE:
30748         jj_consume_token(RAISE);
30749         break;
30750       case RAW:
30751         jj_consume_token(RAW);
30752         break;
30753       case ROWTYPE:
30754         jj_consume_token(ROWTYPE);
30755         break;
30756       case SELECT:
30757         jj_consume_token(SELECT);
30758         break;
30759       case SEPARATE:
30760         jj_consume_token(SEPARATE);
30761         break;
30762       case SHARE:
30763         jj_consume_token(SHARE);
30764         break;
30765       case SMALLINT:
30766         jj_consume_token(SMALLINT);
30767         break;
30768       case SQL:
30769         jj_consume_token(SQL);
30770         break;
30771       case SQLCODE:
30772         jj_consume_token(SQLCODE);
30773         break;
30774       case SQLERRM:
30775         jj_consume_token(SQLERRM);
30776         break;
30777       case START:
30778         jj_consume_token(START);
30779         break;
30780       case STDDEV:
30781         jj_consume_token(STDDEV);
30782         break;
30783       case SUM:
30784         jj_consume_token(SUM);
30785         break;
30786       case SYNONYM:
30787         jj_consume_token(SYNONYM);
30788         break;
30789       case SYSDATE:
30790         jj_consume_token(SYSDATE);
30791         break;
30792       case TABLE:
30793         jj_consume_token(TABLE);
30794         break;
30795       case THEN:
30796         jj_consume_token(THEN);
30797         break;
30798       case TO:
30799         jj_consume_token(TO);
30800         break;
30801       case TRIGGER:
30802         jj_consume_token(TRIGGER);
30803         break;
30804       case TYPE:
30805         jj_consume_token(TYPE);
30806         break;
30807       case UI:
30808         jj_consume_token(UI);
30809         break;
30810       case UPDATE:
30811         jj_consume_token(UPDATE);
30812         break;
30813       case VARCHAR:
30814         jj_consume_token(VARCHAR);
30815         break;
30816       case VARCHAR2:
30817         jj_consume_token(VARCHAR2);
30818         break;
30819       case INT:
30820         jj_consume_token(INT);
30821         break;
30822       case SIGNTYPE:
30823         jj_consume_token(SIGNTYPE);
30824         break;
30825       case STRING:
30826         jj_consume_token(STRING);
30827         break;
30828       case WITH:
30829         jj_consume_token(WITH);
30830         break;
30831       case WHILE:
30832         jj_consume_token(WHILE);
30833         break;
30834       case JAVA_INTERFACE_CLASS:
30835         jj_consume_token(JAVA_INTERFACE_CLASS);
30836         break;
30837       case SQLDATA_CLASS:
30838         jj_consume_token(SQLDATA_CLASS);
30839         break;
30840       case CUSTOMDATUM_CLASS:
30841         jj_consume_token(CUSTOMDATUM_CLASS);
30842         break;
30843       case ORADATA_CLASS:
30844         jj_consume_token(ORADATA_CLASS);
30845         break;
30846       default:
30847         jj_la1[442] = jj_gen;
30848         jj_consume_token(-1);
30849         throw new ParseException();
30850       }
30851           jjtree.closeNodeScope(jjtn000, true);
30852           jjtc000 = false;
30853           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
30854     } catch (Throwable jjte000) {
30855           if (jjtc000) {
30856             jjtree.clearNodeScope(jjtn000);
30857             jjtc000 = false;
30858           } else {
30859             jjtree.popNode();
30860           }
30861           if (jjte000 instanceof RuntimeException) {
30862             {if (true) throw (RuntimeException)jjte000;}
30863           }
30864           if (jjte000 instanceof ParseException) {
30865             {if (true) throw (ParseException)jjte000;}
30866           }
30867           {if (true) throw (Error)jjte000;}
30868     } finally {
30869           if (jjtc000) {
30870             jjtree.closeNodeScope(jjtn000, true);
30871           }
30872     }
30873     throw new Error("Missing return statement in function");
30874   }
30875 
30876 /**
30877  * 2006-05-20 - Matthias Hendler - added <OLD>, <NEW>, <LOOP>, <INT>
30878  */
30879   final public ASTUnqualifiedID UnqualifiedID() throws ParseException {
30880                                    /*@bgen(jjtree) UnqualifiedID */
30881   ASTUnqualifiedID jjtn000 = new ASTUnqualifiedID(this, JJTUNQUALIFIEDID);
30882   boolean jjtc000 = true;
30883   jjtree.openNodeScope(jjtn000);
30884     try {
30885       switch (jj_nt.kind) {
30886       case IDENTIFIER:
30887         jj_consume_token(IDENTIFIER);
30888         break;
30889       case QUOTED_LITERAL:
30890         jj_consume_token(QUOTED_LITERAL);
30891         break;
30892       case DEFINER:
30893       case CURRENT_USER:
30894       case LANGUAGE:
30895       case ADD:
30896       case AGGREGATE:
30897       case AT:
30898       case ATTRIBUTE:
30899       case AUTHID:
30900       case BULK:
30901       case BYTE:
30902       case CASCADE:
30903       case CLOSE:
30904       case COALESCE:
30905       case COLLECT:
30906       case COLUMN:
30907       case COMMENT:
30908       case COMMIT:
30909       case CONSTRUCTOR:
30910       case CONTINUE:
30911       case CONVERT:
30912       case CURRENT:
30913       case CURSOR:
30914       case DATA:
30915       case DAY:
30916       case DISABLE:
30917       case EDITIONABLE:
30918       case ELEMENT:
30919       case ENABLE:
30920       case ESCAPE:
30921       case EXCEPT:
30922       case EXCEPTIONS:
30923       case EXIT:
30924       case EXTERNAL:
30925       case EXTENDS:
30926       case EXTRACT:
30927       case FALSE:
30928       case FINAL:
30929       case FORCE:
30930       case FUNCTION:
30931       case GLOBAL:
30932       case HASH:
30933       case HEAP:
30934       case HOUR:
30935       case IMMEDIATE:
30936       case INDICES:
30937       case INDEXTYPE:
30938       case INDICATOR:
30939       case INSTANTIABLE:
30940       case INTERVAL:
30941       case INVALIDATE:
30942       case ISOLATION:
30943       case JAVA:
30944       case LEVEL:
30945       case LIMIT:
30946       case MAP:
30947       case MAX:
30948       case MEMBER:
30949       case MERGE:
30950       case MIN:
30951       case MINUTE:
30952       case MLSLABEL:
30953       case MODIFY:
30954       case MONTH:
30955       case NATURAL:
30956       case NEW:
30957       case NO:
30958       case NONEDITIONABLE:
30959       case NULLIF:
30960       case OBJECT:
30961       case OID:
30962       case OPAQUE:
30963       case OPEN:
30964       case ORGANIZATION:
30965       case OTHERS:
30966       case OVERRIDING:
30967       case PACKAGE:
30968       case PARTITION:
30969       case PRESERVE:
30970       case PROCEDURE:
30971       case RANGE:
30972       case REAL:
30973       case RECORD:
30974       case REF:
30975       case RELEASE:
30976       case RELIES_ON:
30977       case RENAME:
30978       case RESULT:
30979       case RETURN:
30980       case RETURNING:
30981       case REVERSE:
30982       case ROLLBACK:
30983       case ROW:
30984       case ROWS:
30985       case ROWID:
30986       case ROWNUM:
30987       case SAVE:
30988       case SAVEPOINT:
30989       case SECOND:
30990       case SELF:
30991       case SET:
30992       case SPACE:
30993       case STATIC:
30994       case SUBTYPE:
30995       case SUBSTITUTABLE:
30996       case SUCCESSFUL:
30997       case SYS_REFCURSOR:
30998       case TEMPORARY:
30999       case TIME:
31000       case TIMESTAMP:
31001       case TIMEZONE_REGION:
31002       case TIMEZONE_ABBR:
31003       case TIMEZONE_MINUTE:
31004       case TIMEZONE_HOUR:
31005       case TRANSACTION:
31006       case TRUE:
31007       case UNDER:
31008       case USING:
31009       case YES:
31010       case SHOW:
31011       case A:
31012       case DOUBLE:
31013       case DEC:
31014       case PRECISION:
31015       case NUMERIC:
31016       case NCHAR:
31017       case NVARCHAR2:
31018       case UROWID:
31019       case VARRAY:
31020       case VARYING:
31021       case BFILE:
31022       case BLOB:
31023       case CLOB:
31024       case NCLOB:
31025       case YEAR:
31026       case LOCAL:
31027       case ZONE:
31028       case CHARACTER:
31029       case AFTER:
31030       case BEFORE:
31031       case OLD:
31032       case PARENT:
31033       case ANALYZE:
31034       case ASSOCIATE:
31035       case AUDIT:
31036       case COMPOUND:
31037       case DATABASE:
31038       case CALL:
31039       case DDL:
31040       case DISASSOCIATE:
31041       case EACH:
31042       case FOLLOWS:
31043       case LOGOFF:
31044       case LOGON:
31045       case NESTED:
31046       case NOAUDIT:
31047       case SCHEMA:
31048       case SERVERERROR:
31049       case SHUTDOWN:
31050       case STARTUP:
31051       case STATEMENT:
31052       case STATISTICS:
31053       case SUSPEND:
31054       case TRUNCATE:
31055       case WRAPPED:
31056       case LIBRARY:
31057       case NAME:
31058       case STRUCT:
31059       case CONTEXT:
31060       case PARAMETERS:
31061       case LENGTH:
31062       case TDO:
31063       case MAXLEN:
31064       case CHARSETID:
31065       case CHARSETFORM:
31066       case ACCEPT:
31067       case ACCESSIBLE:
31068       case COPY:
31069       case DEFINE:
31070       case DISCONNECT:
31071       case HOST:
31072       case PRINT:
31073       case QUIT:
31074       case REMARK:
31075       case UNDEFINE:
31076       case VARIABLE:
31077       case WHENEVER:
31078       case ATTACH:
31079       case CAST:
31080       case TREAT:
31081       case TRIM:
31082       case LEFT:
31083       case RIGHT:
31084       case BOTH:
31085       case EMPTY:
31086       case MULTISET:
31087       case SUBMULTISET:
31088       case LEADING:
31089       case TRAILING:
31090       case CHAR_CS:
31091       case NCHAR_CS:
31092       case DBTIMEZONE:
31093       case SESSIONTIMEZONE:
31094       case AUTHENTICATED:
31095       case LINK:
31096       case SHARED:
31097       case DIRECTORY:
31098       case USER:
31099         KEYWORD_UNRESERVED();
31100         break;
31101       case BODY:
31102         jj_consume_token(BODY);
31103         break;
31104       case MOD:
31105         jj_consume_token(MOD);
31106         break;
31107       case OPERATOR:
31108         jj_consume_token(OPERATOR);
31109         break;
31110       case PRIVATE:
31111         jj_consume_token(PRIVATE);
31112         break;
31113       case RAW:
31114         jj_consume_token(RAW);
31115         break;
31116       case REPLACE:
31117         jj_consume_token(REPLACE);
31118         break;
31119       case STRING:
31120         jj_consume_token(STRING);
31121         break;
31122       case SQL:
31123         jj_consume_token(SQL);
31124         break;
31125       case SQLCODE:
31126         jj_consume_token(SQLCODE);
31127         break;
31128       case SQLERRM:
31129         jj_consume_token(SQLERRM);
31130         break;
31131       case SYSDATE:
31132         jj_consume_token(SYSDATE);
31133         break;
31134       case TYPE:
31135         jj_consume_token(TYPE);
31136         break;
31137       case LOOP:
31138         jj_consume_token(LOOP);
31139         break;
31140       case INT:
31141         jj_consume_token(INT);
31142         break;
31143       case ARRAY:
31144         jj_consume_token(ARRAY);
31145         break;
31146       default:
31147         jj_la1[443] = jj_gen;
31148         jj_consume_token(-1);
31149         throw new ParseException();
31150       }
31151           jjtree.closeNodeScope(jjtn000, true);
31152           jjtc000 = false;
31153           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31154     } catch (Throwable jjte000) {
31155           if (jjtc000) {
31156             jjtree.clearNodeScope(jjtn000);
31157             jjtc000 = false;
31158           } else {
31159             jjtree.popNode();
31160           }
31161           if (jjte000 instanceof RuntimeException) {
31162             {if (true) throw (RuntimeException)jjte000;}
31163           }
31164           if (jjte000 instanceof ParseException) {
31165             {if (true) throw (ParseException)jjte000;}
31166           }
31167           {if (true) throw (Error)jjte000;}
31168     } finally {
31169           if (jjtc000) {
31170             jjtree.closeNodeScope(jjtn000, true);
31171           }
31172     }
31173     throw new Error("Missing return statement in function");
31174   }
31175 
31176 /**
31177  * 2006-05-20 - Matthias Hendler - added <LIMIT>
31178  */
31179   final public ASTQualifiedID QualifiedID() throws ParseException {
31180                                /*@bgen(jjtree) QualifiedID */
31181   ASTQualifiedID jjtn000 = new ASTQualifiedID(this, JJTQUALIFIEDID);
31182   boolean jjtc000 = true;
31183   jjtree.openNodeScope(jjtn000);
31184     try {
31185       switch (jj_nt.kind) {
31186       case IDENTIFIER:
31187         jj_consume_token(IDENTIFIER);
31188         break;
31189       case QUOTED_LITERAL:
31190         jj_consume_token(QUOTED_LITERAL);
31191         break;
31192       case DEFINER:
31193       case CURRENT_USER:
31194       case LANGUAGE:
31195       case ADD:
31196       case AGGREGATE:
31197       case AT:
31198       case ATTRIBUTE:
31199       case AUTHID:
31200       case BULK:
31201       case BYTE:
31202       case CASCADE:
31203       case CLOSE:
31204       case COALESCE:
31205       case COLLECT:
31206       case COLUMN:
31207       case COMMENT:
31208       case COMMIT:
31209       case CONSTRUCTOR:
31210       case CONTINUE:
31211       case CONVERT:
31212       case CURRENT:
31213       case CURSOR:
31214       case DATA:
31215       case DAY:
31216       case DISABLE:
31217       case EDITIONABLE:
31218       case ELEMENT:
31219       case ENABLE:
31220       case ESCAPE:
31221       case EXCEPT:
31222       case EXCEPTIONS:
31223       case EXIT:
31224       case EXTERNAL:
31225       case EXTENDS:
31226       case EXTRACT:
31227       case FALSE:
31228       case FINAL:
31229       case FORCE:
31230       case FUNCTION:
31231       case GLOBAL:
31232       case HASH:
31233       case HEAP:
31234       case HOUR:
31235       case IMMEDIATE:
31236       case INDICES:
31237       case INDEXTYPE:
31238       case INDICATOR:
31239       case INSTANTIABLE:
31240       case INTERVAL:
31241       case INVALIDATE:
31242       case ISOLATION:
31243       case JAVA:
31244       case LEVEL:
31245       case LIMIT:
31246       case MAP:
31247       case MAX:
31248       case MEMBER:
31249       case MERGE:
31250       case MIN:
31251       case MINUTE:
31252       case MLSLABEL:
31253       case MODIFY:
31254       case MONTH:
31255       case NATURAL:
31256       case NEW:
31257       case NO:
31258       case NONEDITIONABLE:
31259       case NULLIF:
31260       case OBJECT:
31261       case OID:
31262       case OPAQUE:
31263       case OPEN:
31264       case ORGANIZATION:
31265       case OTHERS:
31266       case OVERRIDING:
31267       case PACKAGE:
31268       case PARTITION:
31269       case PRESERVE:
31270       case PROCEDURE:
31271       case RANGE:
31272       case REAL:
31273       case RECORD:
31274       case REF:
31275       case RELEASE:
31276       case RELIES_ON:
31277       case RENAME:
31278       case RESULT:
31279       case RETURN:
31280       case RETURNING:
31281       case REVERSE:
31282       case ROLLBACK:
31283       case ROW:
31284       case ROWS:
31285       case ROWID:
31286       case ROWNUM:
31287       case SAVE:
31288       case SAVEPOINT:
31289       case SECOND:
31290       case SELF:
31291       case SET:
31292       case SPACE:
31293       case STATIC:
31294       case SUBTYPE:
31295       case SUBSTITUTABLE:
31296       case SUCCESSFUL:
31297       case SYS_REFCURSOR:
31298       case TEMPORARY:
31299       case TIME:
31300       case TIMESTAMP:
31301       case TIMEZONE_REGION:
31302       case TIMEZONE_ABBR:
31303       case TIMEZONE_MINUTE:
31304       case TIMEZONE_HOUR:
31305       case TRANSACTION:
31306       case TRUE:
31307       case UNDER:
31308       case USING:
31309       case YES:
31310       case SHOW:
31311       case A:
31312       case DOUBLE:
31313       case DEC:
31314       case PRECISION:
31315       case NUMERIC:
31316       case NCHAR:
31317       case NVARCHAR2:
31318       case UROWID:
31319       case VARRAY:
31320       case VARYING:
31321       case BFILE:
31322       case BLOB:
31323       case CLOB:
31324       case NCLOB:
31325       case YEAR:
31326       case LOCAL:
31327       case ZONE:
31328       case CHARACTER:
31329       case AFTER:
31330       case BEFORE:
31331       case OLD:
31332       case PARENT:
31333       case ANALYZE:
31334       case ASSOCIATE:
31335       case AUDIT:
31336       case COMPOUND:
31337       case DATABASE:
31338       case CALL:
31339       case DDL:
31340       case DISASSOCIATE:
31341       case EACH:
31342       case FOLLOWS:
31343       case LOGOFF:
31344       case LOGON:
31345       case NESTED:
31346       case NOAUDIT:
31347       case SCHEMA:
31348       case SERVERERROR:
31349       case SHUTDOWN:
31350       case STARTUP:
31351       case STATEMENT:
31352       case STATISTICS:
31353       case SUSPEND:
31354       case TRUNCATE:
31355       case WRAPPED:
31356       case LIBRARY:
31357       case NAME:
31358       case STRUCT:
31359       case CONTEXT:
31360       case PARAMETERS:
31361       case LENGTH:
31362       case TDO:
31363       case MAXLEN:
31364       case CHARSETID:
31365       case CHARSETFORM:
31366       case ACCEPT:
31367       case ACCESSIBLE:
31368       case COPY:
31369       case DEFINE:
31370       case DISCONNECT:
31371       case HOST:
31372       case PRINT:
31373       case QUIT:
31374       case REMARK:
31375       case UNDEFINE:
31376       case VARIABLE:
31377       case WHENEVER:
31378       case ATTACH:
31379       case CAST:
31380       case TREAT:
31381       case TRIM:
31382       case LEFT:
31383       case RIGHT:
31384       case BOTH:
31385       case EMPTY:
31386       case MULTISET:
31387       case SUBMULTISET:
31388       case LEADING:
31389       case TRAILING:
31390       case CHAR_CS:
31391       case NCHAR_CS:
31392       case DBTIMEZONE:
31393       case SESSIONTIMEZONE:
31394       case AUTHENTICATED:
31395       case LINK:
31396       case SHARED:
31397       case DIRECTORY:
31398       case USER:
31399         KEYWORD_UNRESERVED();
31400         break;
31401       case REPLACE:
31402         jj_consume_token(REPLACE);
31403         break;
31404       case SERIALLY_REUSABLE:
31405         jj_consume_token(SERIALLY_REUSABLE);
31406         break;
31407       case RESTRICT_REFERENCES:
31408         jj_consume_token(RESTRICT_REFERENCES);
31409         break;
31410       case EXCEPTION_INIT:
31411         jj_consume_token(EXCEPTION_INIT);
31412         break;
31413       case AUTONOMOUS_TRANSACTION:
31414         jj_consume_token(AUTONOMOUS_TRANSACTION);
31415         break;
31416       case ARRAY:
31417         jj_consume_token(ARRAY);
31418         break;
31419       case AVG:
31420         jj_consume_token(AVG);
31421         break;
31422       case BINARY_INTEGER:
31423         jj_consume_token(BINARY_INTEGER);
31424         break;
31425       case BODY:
31426         jj_consume_token(BODY);
31427         break;
31428       case BOOLEAN:
31429         jj_consume_token(BOOLEAN);
31430         break;
31431       case CHAR:
31432         jj_consume_token(CHAR);
31433         break;
31434       case CHAR_BASE:
31435         jj_consume_token(CHAR_BASE);
31436         break;
31437       case CONSTANT:
31438         jj_consume_token(CONSTANT);
31439         break;
31440       case CURRVAL:
31441         jj_consume_token(CURRVAL);
31442         break;
31443       case DATE:
31444         jj_consume_token(DATE);
31445         break;
31446       case DECIMAL:
31447         jj_consume_token(DECIMAL);
31448         break;
31449       case DELETE:
31450         jj_consume_token(DELETE);
31451         break;
31452       case DO:
31453         jj_consume_token(DO);
31454         break;
31455       case ELSIF:
31456         jj_consume_token(ELSIF);
31457         break;
31458       case EXECUTE:
31459         jj_consume_token(EXECUTE);
31460         break;
31461       case EXISTS:
31462         jj_consume_token(EXISTS);
31463         break;
31464       case FLOAT:
31465         jj_consume_token(FLOAT);
31466         break;
31467       case FORALL:
31468         jj_consume_token(FORALL);
31469         break;
31470       case INTEGER:
31471         jj_consume_token(INTEGER);
31472         break;
31473       case INTERFACE:
31474         jj_consume_token(INTERFACE);
31475         break;
31476       case LONG:
31477         jj_consume_token(LONG);
31478         break;
31479       case LOOP:
31480         jj_consume_token(LOOP);
31481         break;
31482       case MOD:
31483         jj_consume_token(MOD);
31484         break;
31485       case NATURALN:
31486         jj_consume_token(NATURALN);
31487         break;
31488       case NEXTVAL:
31489         jj_consume_token(NEXTVAL);
31490         break;
31491       case NOCOPY:
31492         jj_consume_token(NOCOPY);
31493         break;
31494       case NUMBER:
31495         jj_consume_token(NUMBER);
31496         break;
31497       case BFILE_BASE:
31498         jj_consume_token(BFILE_BASE);
31499         break;
31500       case BLOB_BASE:
31501         jj_consume_token(BLOB_BASE);
31502         break;
31503       case CLOB_BASE:
31504         jj_consume_token(CLOB_BASE);
31505         break;
31506       case DATE_BASE:
31507         jj_consume_token(DATE_BASE);
31508         break;
31509       case NUMBER_BASE:
31510         jj_consume_token(NUMBER_BASE);
31511         break;
31512       case OCIROWID:
31513         jj_consume_token(OCIROWID);
31514         break;
31515       case OPERATOR:
31516         jj_consume_token(OPERATOR);
31517         break;
31518       case OUT:
31519         jj_consume_token(OUT);
31520         break;
31521       case PLS_INTEGER:
31522         jj_consume_token(PLS_INTEGER);
31523         break;
31524       case POSITIVE:
31525         jj_consume_token(POSITIVE);
31526         break;
31527       case POSITIVEN:
31528         jj_consume_token(POSITIVEN);
31529         break;
31530       case PRAGMA:
31531         jj_consume_token(PRAGMA);
31532         break;
31533       case PRIOR:
31534         jj_consume_token(PRIOR);
31535         break;
31536       case PRIVATE:
31537         jj_consume_token(PRIVATE);
31538         break;
31539       case PROMPT:
31540         jj_consume_token(PROMPT);
31541         break;
31542       case RAISE:
31543         jj_consume_token(RAISE);
31544         break;
31545       case RAW:
31546         jj_consume_token(RAW);
31547         break;
31548       case ROWTYPE:
31549         jj_consume_token(ROWTYPE);
31550         break;
31551       case SEPARATE:
31552         jj_consume_token(SEPARATE);
31553         break;
31554       case SMALLINT:
31555         jj_consume_token(SMALLINT);
31556         break;
31557       case SQLCODE:
31558         jj_consume_token(SQLCODE);
31559         break;
31560       case SQLERRM:
31561         jj_consume_token(SQLERRM);
31562         break;
31563       case STDDEV:
31564         jj_consume_token(STDDEV);
31565         break;
31566       case SUM:
31567         jj_consume_token(SUM);
31568         break;
31569       case SYNONYM:
31570         jj_consume_token(SYNONYM);
31571         break;
31572       case SYSDATE:
31573         jj_consume_token(SYSDATE);
31574         break;
31575       case TRIGGER:
31576         jj_consume_token(TRIGGER);
31577         break;
31578       case TYPE:
31579         jj_consume_token(TYPE);
31580         break;
31581       case UI:
31582         jj_consume_token(UI);
31583         break;
31584       case VARCHAR:
31585         jj_consume_token(VARCHAR);
31586         break;
31587       case VARCHAR2:
31588         jj_consume_token(VARCHAR2);
31589         break;
31590       case INT:
31591         jj_consume_token(INT);
31592         break;
31593       case SIGNTYPE:
31594         jj_consume_token(SIGNTYPE);
31595         break;
31596       case STRING:
31597         jj_consume_token(STRING);
31598         break;
31599       case WHILE:
31600         jj_consume_token(WHILE);
31601         break;
31602       default:
31603         jj_la1[444] = jj_gen;
31604         jj_consume_token(-1);
31605         throw new ParseException();
31606       }
31607           jjtree.closeNodeScope(jjtn000, true);
31608           jjtc000 = false;
31609           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31610     } catch (Throwable jjte000) {
31611           if (jjtc000) {
31612             jjtree.clearNodeScope(jjtn000);
31613             jjtc000 = false;
31614           } else {
31615             jjtree.popNode();
31616           }
31617           if (jjte000 instanceof RuntimeException) {
31618             {if (true) throw (RuntimeException)jjte000;}
31619           }
31620           if (jjte000 instanceof ParseException) {
31621             {if (true) throw (ParseException)jjte000;}
31622           }
31623           {if (true) throw (Error)jjte000;}
31624     } finally {
31625           if (jjtc000) {
31626             jjtree.closeNodeScope(jjtn000, true);
31627           }
31628     }
31629     throw new Error("Missing return statement in function");
31630   }
31631 
31632   final public ASTTypeKeyword TypeKeyword() throws ParseException {
31633                                /*@bgen(jjtree) TypeKeyword */
31634   ASTTypeKeyword jjtn000 = new ASTTypeKeyword(this, JJTTYPEKEYWORD);
31635   boolean jjtc000 = true;
31636   jjtree.openNodeScope(jjtn000);
31637     try {
31638       switch (jj_nt.kind) {
31639       case BFILE_BASE:
31640         jj_consume_token(BFILE_BASE);
31641         break;
31642       case BLOB_BASE:
31643         jj_consume_token(BLOB_BASE);
31644         break;
31645       case CLOB_BASE:
31646         jj_consume_token(CLOB_BASE);
31647         break;
31648       case DATE_BASE:
31649         jj_consume_token(DATE_BASE);
31650         break;
31651       case NUMBER_BASE:
31652         jj_consume_token(NUMBER_BASE);
31653         break;
31654       case BOOLEAN:
31655         jj_consume_token(BOOLEAN);
31656         break;
31657       case DATE:
31658         jj_consume_token(DATE);
31659         break;
31660       case NUMBER:
31661         jj_consume_token(NUMBER);
31662         break;
31663       case FLOAT:
31664         jj_consume_token(FLOAT);
31665         break;
31666       case REAL:
31667         jj_consume_token(REAL);
31668         break;
31669       case INTEGER:
31670         jj_consume_token(INTEGER);
31671         break;
31672       case INT:
31673         jj_consume_token(INT);
31674         break;
31675       case SMALLINT:
31676         jj_consume_token(SMALLINT);
31677         break;
31678       case DECIMAL:
31679         jj_consume_token(DECIMAL);
31680         break;
31681       case NUMERIC:
31682         jj_consume_token(NUMERIC);
31683         break;
31684       case DEC:
31685         jj_consume_token(DEC);
31686         break;
31687       case BINARY_INTEGER:
31688         jj_consume_token(BINARY_INTEGER);
31689         break;
31690       case NATURAL:
31691         jj_consume_token(NATURAL);
31692         break;
31693       case NATURALN:
31694         jj_consume_token(NATURALN);
31695         break;
31696       case POSITIVE:
31697         jj_consume_token(POSITIVE);
31698         break;
31699       case POSITIVEN:
31700         jj_consume_token(POSITIVEN);
31701         break;
31702       case SIGNTYPE:
31703         jj_consume_token(SIGNTYPE);
31704         break;
31705       case VARCHAR2:
31706         jj_consume_token(VARCHAR2);
31707         break;
31708       case VARCHAR:
31709         jj_consume_token(VARCHAR);
31710         break;
31711       case STRING:
31712         jj_consume_token(STRING);
31713         break;
31714       case LONG:
31715         jj_consume_token(LONG);
31716         break;
31717       case RAW:
31718         jj_consume_token(RAW);
31719         break;
31720       case ROWID:
31721         jj_consume_token(ROWID);
31722         break;
31723       case CHAR:
31724         jj_consume_token(CHAR);
31725         break;
31726       case CHARACTER:
31727         jj_consume_token(CHARACTER);
31728         break;
31729       case MLSLABEL:
31730         jj_consume_token(MLSLABEL);
31731         break;
31732       case BLOB:
31733         jj_consume_token(BLOB);
31734         break;
31735       case CLOB:
31736         jj_consume_token(CLOB);
31737         break;
31738       case BFILE:
31739         jj_consume_token(BFILE);
31740         break;
31741       case NCHAR:
31742         jj_consume_token(NCHAR);
31743         break;
31744       case NVARCHAR2:
31745         jj_consume_token(NVARCHAR2);
31746         break;
31747       case NCLOB:
31748         jj_consume_token(NCLOB);
31749         break;
31750       case PLS_INTEGER:
31751         jj_consume_token(PLS_INTEGER);
31752         break;
31753       case TIME:
31754         jj_consume_token(TIME);
31755         break;
31756       case TIMESTAMP:
31757         jj_consume_token(TIMESTAMP);
31758         break;
31759       case UROWID:
31760         jj_consume_token(UROWID);
31761         break;
31762       case ARRAY:
31763         jj_consume_token(ARRAY);
31764         break;
31765       case AUTHID:
31766         jj_consume_token(AUTHID);
31767         break;
31768       case ACCESSIBLE:
31769         jj_consume_token(ACCESSIBLE);
31770         jj_consume_token(CHAR_BASE);
31771         break;
31772       case CURRVAL:
31773         jj_consume_token(CURRVAL);
31774         break;
31775       case HOUR:
31776         jj_consume_token(HOUR);
31777         break;
31778       case INTERVAL:
31779         jj_consume_token(INTERVAL);
31780         break;
31781       case MONTH:
31782         jj_consume_token(MONTH);
31783         break;
31784       case OCIROWID:
31785         jj_consume_token(OCIROWID);
31786         break;
31787       case RECORD:
31788         jj_consume_token(RECORD);
31789         break;
31790       case REF:
31791         jj_consume_token(REF);
31792         break;
31793       case ROW:
31794         jj_consume_token(ROW);
31795         break;
31796       case ROWNUM:
31797         jj_consume_token(ROWNUM);
31798         break;
31799       case ROWTYPE:
31800         jj_consume_token(ROWTYPE);
31801         break;
31802       case SECOND:
31803         jj_consume_token(SECOND);
31804         break;
31805       case SET:
31806         jj_consume_token(SET);
31807         break;
31808       case TABLE:
31809         jj_consume_token(TABLE);
31810         break;
31811       case TIMEZONE_REGION:
31812         jj_consume_token(TIMEZONE_REGION);
31813         break;
31814       case TIMEZONE_ABBR:
31815         jj_consume_token(TIMEZONE_ABBR);
31816         break;
31817       case TIMEZONE_MINUTE:
31818         jj_consume_token(TIMEZONE_MINUTE);
31819         break;
31820       case TIMEZONE_HOUR:
31821         jj_consume_token(TIMEZONE_HOUR);
31822         break;
31823       case DOUBLE:
31824         jj_consume_token(DOUBLE);
31825         break;
31826       case PRECISION:
31827         jj_consume_token(PRECISION);
31828         break;
31829       case VARRAY:
31830         jj_consume_token(VARRAY);
31831         break;
31832       case YEAR:
31833         jj_consume_token(YEAR);
31834         break;
31835       case LOCAL:
31836         jj_consume_token(LOCAL);
31837         break;
31838       case WITH:
31839         jj_consume_token(WITH);
31840         break;
31841       case ZONE:
31842         jj_consume_token(ZONE);
31843         break;
31844       case JAVA_INTERFACE_CLASS:
31845         jj_consume_token(JAVA_INTERFACE_CLASS);
31846         break;
31847       case SQLDATA_CLASS:
31848         jj_consume_token(SQLDATA_CLASS);
31849         break;
31850       case CUSTOMDATUM_CLASS:
31851         jj_consume_token(CUSTOMDATUM_CLASS);
31852         break;
31853       case ORADATA_CLASS:
31854         jj_consume_token(ORADATA_CLASS);
31855         break;
31856       default:
31857         jj_la1[445] = jj_gen;
31858         jj_consume_token(-1);
31859         throw new ParseException();
31860       }
31861           jjtree.closeNodeScope(jjtn000, true);
31862           jjtc000 = false;
31863           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31864     } finally {
31865           if (jjtc000) {
31866             jjtree.closeNodeScope(jjtn000, true);
31867           }
31868     }
31869     throw new Error("Missing return statement in function");
31870   }
31871 
31872   final public ASTJavaInterfaceClass JavaInterfaceClass() throws ParseException {
31873                                              /*@bgen(jjtree) JavaInterfaceClass */
31874   ASTJavaInterfaceClass jjtn000 = new ASTJavaInterfaceClass(this, JJTJAVAINTERFACECLASS);
31875   boolean jjtc000 = true;
31876   jjtree.openNodeScope(jjtn000);
31877     try {
31878       switch (jj_nt.kind) {
31879       case SQLDATA_CLASS:
31880         jj_consume_token(SQLDATA_CLASS);
31881         break;
31882       case CUSTOMDATUM_CLASS:
31883         jj_consume_token(CUSTOMDATUM_CLASS);
31884         break;
31885       case ORADATA_CLASS:
31886         jj_consume_token(ORADATA_CLASS);
31887         break;
31888       default:
31889         jj_la1[446] = jj_gen;
31890         jj_consume_token(-1);
31891         throw new ParseException();
31892       }
31893           jjtree.closeNodeScope(jjtn000, true);
31894           jjtc000 = false;
31895           jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31896     } finally {
31897           if (jjtc000) {
31898             jjtree.closeNodeScope(jjtn000, true);
31899           }
31900     }
31901     throw new Error("Missing return statement in function");
31902   }
31903 
31904 /**
31905  * Tests, if the new Token if type ID is identical to the old Token of type ID.
31906  * 
31907  * 2006-05-18 - Matthias Hendler - added: Just for understanding javacc and not used,
31908  *                                        cause to many closing ENDs (IDENTIFIER) were mistyped.
31909  */
31910   final public PLSQLNode EqualsOldIDNewID(PLSQLNode pOldID) throws ParseException {
31911  /*@bgen(jjtree) EqualsOldIDNewID */
31912         ASTEqualsOldIDNewID jjtn000 = new ASTEqualsOldIDNewID(this, JJTEQUALSOLDIDNEWID);
31913         boolean jjtc000 = true;
31914         jjtree.openNodeScope(jjtn000);PLSQLNode newID;
31915         Token oldIDToken;
31916         Token newIDToken;
31917     try {
31918       newID = ID();
31919           jjtree.closeNodeScope(jjtn000, true);
31920           jjtc000 = false;
31921                 oldIDToken = (Token) ((AbstractPLSQLNode)pOldID).value ;
31922                 newIDToken = (Token) ((AbstractPLSQLNode)newID).value ;
31923                 if (oldIDToken.image.equals(newIDToken.image)) {
31924                         {if (true) return newID;}
31925                 } else {
31926                         {if (true) throw new ParseException("PLSQL syntax error on line "+newIDToken.beginLine+" at column "+newIDToken.beginColumn+"!\u005cn"
31927                                 + "Found \u005c""+newIDToken.image+"\u005c" but expected \u005c""+oldIDToken.image+"\u005c".");}
31928                 }
31929     } catch (Throwable jjte000) {
31930           if (jjtc000) {
31931             jjtree.clearNodeScope(jjtn000);
31932             jjtc000 = false;
31933           } else {
31934             jjtree.popNode();
31935           }
31936           if (jjte000 instanceof RuntimeException) {
31937             {if (true) throw (RuntimeException)jjte000;}
31938           }
31939           if (jjte000 instanceof ParseException) {
31940             {if (true) throw (ParseException)jjte000;}
31941           }
31942           {if (true) throw (Error)jjte000;}
31943     } finally {
31944           if (jjtc000) {
31945             jjtree.closeNodeScope(jjtn000, true);
31946           }
31947     }
31948     throw new Error("Missing return statement in function");
31949   }
31950 
31951   private boolean jj_2_1(int xla) {
31952     jj_la = xla; jj_lastpos = jj_scanpos = token;
31953     try { return !jj_3_1(); }
31954     catch(LookaheadSuccess ls) { return true; }
31955     finally { jj_save(0, xla); }
31956   }
31957 
31958   private boolean jj_2_2(int xla) {
31959     jj_la = xla; jj_lastpos = jj_scanpos = token;
31960     try { return !jj_3_2(); }
31961     catch(LookaheadSuccess ls) { return true; }
31962     finally { jj_save(1, xla); }
31963   }
31964 
31965   private boolean jj_2_3(int xla) {
31966     jj_la = xla; jj_lastpos = jj_scanpos = token;
31967     try { return !jj_3_3(); }
31968     catch(LookaheadSuccess ls) { return true; }
31969     finally { jj_save(2, xla); }
31970   }
31971 
31972   private boolean jj_2_4(int xla) {
31973     jj_la = xla; jj_lastpos = jj_scanpos = token;
31974     try { return !jj_3_4(); }
31975     catch(LookaheadSuccess ls) { return true; }
31976     finally { jj_save(3, xla); }
31977   }
31978 
31979   private boolean jj_2_5(int xla) {
31980     jj_la = xla; jj_lastpos = jj_scanpos = token;
31981     try { return !jj_3_5(); }
31982     catch(LookaheadSuccess ls) { return true; }
31983     finally { jj_save(4, xla); }
31984   }
31985 
31986   private boolean jj_2_6(int xla) {
31987     jj_la = xla; jj_lastpos = jj_scanpos = token;
31988     try { return !jj_3_6(); }
31989     catch(LookaheadSuccess ls) { return true; }
31990     finally { jj_save(5, xla); }
31991   }
31992 
31993   private boolean jj_2_7(int xla) {
31994     jj_la = xla; jj_lastpos = jj_scanpos = token;
31995     try { return !jj_3_7(); }
31996     catch(LookaheadSuccess ls) { return true; }
31997     finally { jj_save(6, xla); }
31998   }
31999 
32000   private boolean jj_2_8(int xla) {
32001     jj_la = xla; jj_lastpos = jj_scanpos = token;
32002     try { return !jj_3_8(); }
32003     catch(LookaheadSuccess ls) { return true; }
32004     finally { jj_save(7, xla); }
32005   }
32006 
32007   private boolean jj_2_9(int xla) {
32008     jj_la = xla; jj_lastpos = jj_scanpos = token;
32009     try { return !jj_3_9(); }
32010     catch(LookaheadSuccess ls) { return true; }
32011     finally { jj_save(8, xla); }
32012   }
32013 
32014   private boolean jj_2_10(int xla) {
32015     jj_la = xla; jj_lastpos = jj_scanpos = token;
32016     try { return !jj_3_10(); }
32017     catch(LookaheadSuccess ls) { return true; }
32018     finally { jj_save(9, xla); }
32019   }
32020 
32021   private boolean jj_2_11(int xla) {
32022     jj_la = xla; jj_lastpos = jj_scanpos = token;
32023     try { return !jj_3_11(); }
32024     catch(LookaheadSuccess ls) { return true; }
32025     finally { jj_save(10, xla); }
32026   }
32027 
32028   private boolean jj_2_12(int xla) {
32029     jj_la = xla; jj_lastpos = jj_scanpos = token;
32030     try { return !jj_3_12(); }
32031     catch(LookaheadSuccess ls) { return true; }
32032     finally { jj_save(11, xla); }
32033   }
32034 
32035   private boolean jj_2_13(int xla) {
32036     jj_la = xla; jj_lastpos = jj_scanpos = token;
32037     try { return !jj_3_13(); }
32038     catch(LookaheadSuccess ls) { return true; }
32039     finally { jj_save(12, xla); }
32040   }
32041 
32042   private boolean jj_2_14(int xla) {
32043     jj_la = xla; jj_lastpos = jj_scanpos = token;
32044     try { return !jj_3_14(); }
32045     catch(LookaheadSuccess ls) { return true; }
32046     finally { jj_save(13, xla); }
32047   }
32048 
32049   private boolean jj_2_15(int xla) {
32050     jj_la = xla; jj_lastpos = jj_scanpos = token;
32051     try { return !jj_3_15(); }
32052     catch(LookaheadSuccess ls) { return true; }
32053     finally { jj_save(14, xla); }
32054   }
32055 
32056   private boolean jj_2_16(int xla) {
32057     jj_la = xla; jj_lastpos = jj_scanpos = token;
32058     try { return !jj_3_16(); }
32059     catch(LookaheadSuccess ls) { return true; }
32060     finally { jj_save(15, xla); }
32061   }
32062 
32063   private boolean jj_2_17(int xla) {
32064     jj_la = xla; jj_lastpos = jj_scanpos = token;
32065     try { return !jj_3_17(); }
32066     catch(LookaheadSuccess ls) { return true; }
32067     finally { jj_save(16, xla); }
32068   }
32069 
32070   private boolean jj_2_18(int xla) {
32071     jj_la = xla; jj_lastpos = jj_scanpos = token;
32072     try { return !jj_3_18(); }
32073     catch(LookaheadSuccess ls) { return true; }
32074     finally { jj_save(17, xla); }
32075   }
32076 
32077   private boolean jj_2_19(int xla) {
32078     jj_la = xla; jj_lastpos = jj_scanpos = token;
32079     try { return !jj_3_19(); }
32080     catch(LookaheadSuccess ls) { return true; }
32081     finally { jj_save(18, xla); }
32082   }
32083 
32084   private boolean jj_2_20(int xla) {
32085     jj_la = xla; jj_lastpos = jj_scanpos = token;
32086     try { return !jj_3_20(); }
32087     catch(LookaheadSuccess ls) { return true; }
32088     finally { jj_save(19, xla); }
32089   }
32090 
32091   private boolean jj_2_21(int xla) {
32092     jj_la = xla; jj_lastpos = jj_scanpos = token;
32093     try { return !jj_3_21(); }
32094     catch(LookaheadSuccess ls) { return true; }
32095     finally { jj_save(20, xla); }
32096   }
32097 
32098   private boolean jj_2_22(int xla) {
32099     jj_la = xla; jj_lastpos = jj_scanpos = token;
32100     try { return !jj_3_22(); }
32101     catch(LookaheadSuccess ls) { return true; }
32102     finally { jj_save(21, xla); }
32103   }
32104 
32105   private boolean jj_2_23(int xla) {
32106     jj_la = xla; jj_lastpos = jj_scanpos = token;
32107     try { return !jj_3_23(); }
32108     catch(LookaheadSuccess ls) { return true; }
32109     finally { jj_save(22, xla); }
32110   }
32111 
32112   private boolean jj_2_24(int xla) {
32113     jj_la = xla; jj_lastpos = jj_scanpos = token;
32114     try { return !jj_3_24(); }
32115     catch(LookaheadSuccess ls) { return true; }
32116     finally { jj_save(23, xla); }
32117   }
32118 
32119   private boolean jj_2_25(int xla) {
32120     jj_la = xla; jj_lastpos = jj_scanpos = token;
32121     try { return !jj_3_25(); }
32122     catch(LookaheadSuccess ls) { return true; }
32123     finally { jj_save(24, xla); }
32124   }
32125 
32126   private boolean jj_2_26(int xla) {
32127     jj_la = xla; jj_lastpos = jj_scanpos = token;
32128     try { return !jj_3_26(); }
32129     catch(LookaheadSuccess ls) { return true; }
32130     finally { jj_save(25, xla); }
32131   }
32132 
32133   private boolean jj_2_27(int xla) {
32134     jj_la = xla; jj_lastpos = jj_scanpos = token;
32135     try { return !jj_3_27(); }
32136     catch(LookaheadSuccess ls) { return true; }
32137     finally { jj_save(26, xla); }
32138   }
32139 
32140   private boolean jj_2_28(int xla) {
32141     jj_la = xla; jj_lastpos = jj_scanpos = token;
32142     try { return !jj_3_28(); }
32143     catch(LookaheadSuccess ls) { return true; }
32144     finally { jj_save(27, xla); }
32145   }
32146 
32147   private boolean jj_2_29(int xla) {
32148     jj_la = xla; jj_lastpos = jj_scanpos = token;
32149     try { return !jj_3_29(); }
32150     catch(LookaheadSuccess ls) { return true; }
32151     finally { jj_save(28, xla); }
32152   }
32153 
32154   private boolean jj_2_30(int xla) {
32155     jj_la = xla; jj_lastpos = jj_scanpos = token;
32156     try { return !jj_3_30(); }
32157     catch(LookaheadSuccess ls) { return true; }
32158     finally { jj_save(29, xla); }
32159   }
32160 
32161   private boolean jj_2_31(int xla) {
32162     jj_la = xla; jj_lastpos = jj_scanpos = token;
32163     try { return !jj_3_31(); }
32164     catch(LookaheadSuccess ls) { return true; }
32165     finally { jj_save(30, xla); }
32166   }
32167 
32168   private boolean jj_2_32(int xla) {
32169     jj_la = xla; jj_lastpos = jj_scanpos = token;
32170     try { return !jj_3_32(); }
32171     catch(LookaheadSuccess ls) { return true; }
32172     finally { jj_save(31, xla); }
32173   }
32174 
32175   private boolean jj_2_33(int xla) {
32176     jj_la = xla; jj_lastpos = jj_scanpos = token;
32177     try { return !jj_3_33(); }
32178     catch(LookaheadSuccess ls) { return true; }
32179     finally { jj_save(32, xla); }
32180   }
32181 
32182   private boolean jj_2_34(int xla) {
32183     jj_la = xla; jj_lastpos = jj_scanpos = token;
32184     try { return !jj_3_34(); }
32185     catch(LookaheadSuccess ls) { return true; }
32186     finally { jj_save(33, xla); }
32187   }
32188 
32189   private boolean jj_2_35(int xla) {
32190     jj_la = xla; jj_lastpos = jj_scanpos = token;
32191     try { return !jj_3_35(); }
32192     catch(LookaheadSuccess ls) { return true; }
32193     finally { jj_save(34, xla); }
32194   }
32195 
32196   private boolean jj_2_36(int xla) {
32197     jj_la = xla; jj_lastpos = jj_scanpos = token;
32198     try { return !jj_3_36(); }
32199     catch(LookaheadSuccess ls) { return true; }
32200     finally { jj_save(35, xla); }
32201   }
32202 
32203   private boolean jj_2_37(int xla) {
32204     jj_la = xla; jj_lastpos = jj_scanpos = token;
32205     try { return !jj_3_37(); }
32206     catch(LookaheadSuccess ls) { return true; }
32207     finally { jj_save(36, xla); }
32208   }
32209 
32210   private boolean jj_2_38(int xla) {
32211     jj_la = xla; jj_lastpos = jj_scanpos = token;
32212     try { return !jj_3_38(); }
32213     catch(LookaheadSuccess ls) { return true; }
32214     finally { jj_save(37, xla); }
32215   }
32216 
32217   private boolean jj_2_39(int xla) {
32218     jj_la = xla; jj_lastpos = jj_scanpos = token;
32219     try { return !jj_3_39(); }
32220     catch(LookaheadSuccess ls) { return true; }
32221     finally { jj_save(38, xla); }
32222   }
32223 
32224   private boolean jj_2_40(int xla) {
32225     jj_la = xla; jj_lastpos = jj_scanpos = token;
32226     try { return !jj_3_40(); }
32227     catch(LookaheadSuccess ls) { return true; }
32228     finally { jj_save(39, xla); }
32229   }
32230 
32231   private boolean jj_2_41(int xla) {
32232     jj_la = xla; jj_lastpos = jj_scanpos = token;
32233     try { return !jj_3_41(); }
32234     catch(LookaheadSuccess ls) { return true; }
32235     finally { jj_save(40, xla); }
32236   }
32237 
32238   private boolean jj_2_42(int xla) {
32239     jj_la = xla; jj_lastpos = jj_scanpos = token;
32240     try { return !jj_3_42(); }
32241     catch(LookaheadSuccess ls) { return true; }
32242     finally { jj_save(41, xla); }
32243   }
32244 
32245   private boolean jj_2_43(int xla) {
32246     jj_la = xla; jj_lastpos = jj_scanpos = token;
32247     try { return !jj_3_43(); }
32248     catch(LookaheadSuccess ls) { return true; }
32249     finally { jj_save(42, xla); }
32250   }
32251 
32252   private boolean jj_2_44(int xla) {
32253     jj_la = xla; jj_lastpos = jj_scanpos = token;
32254     try { return !jj_3_44(); }
32255     catch(LookaheadSuccess ls) { return true; }
32256     finally { jj_save(43, xla); }
32257   }
32258 
32259   private boolean jj_2_45(int xla) {
32260     jj_la = xla; jj_lastpos = jj_scanpos = token;
32261     try { return !jj_3_45(); }
32262     catch(LookaheadSuccess ls) { return true; }
32263     finally { jj_save(44, xla); }
32264   }
32265 
32266   private boolean jj_2_46(int xla) {
32267     jj_la = xla; jj_lastpos = jj_scanpos = token;
32268     try { return !jj_3_46(); }
32269     catch(LookaheadSuccess ls) { return true; }
32270     finally { jj_save(45, xla); }
32271   }
32272 
32273   private boolean jj_2_47(int xla) {
32274     jj_la = xla; jj_lastpos = jj_scanpos = token;
32275     try { return !jj_3_47(); }
32276     catch(LookaheadSuccess ls) { return true; }
32277     finally { jj_save(46, xla); }
32278   }
32279 
32280   private boolean jj_2_48(int xla) {
32281     jj_la = xla; jj_lastpos = jj_scanpos = token;
32282     try { return !jj_3_48(); }
32283     catch(LookaheadSuccess ls) { return true; }
32284     finally { jj_save(47, xla); }
32285   }
32286 
32287   private boolean jj_2_49(int xla) {
32288     jj_la = xla; jj_lastpos = jj_scanpos = token;
32289     try { return !jj_3_49(); }
32290     catch(LookaheadSuccess ls) { return true; }
32291     finally { jj_save(48, xla); }
32292   }
32293 
32294   private boolean jj_2_50(int xla) {
32295     jj_la = xla; jj_lastpos = jj_scanpos = token;
32296     try { return !jj_3_50(); }
32297     catch(LookaheadSuccess ls) { return true; }
32298     finally { jj_save(49, xla); }
32299   }
32300 
32301   private boolean jj_2_51(int xla) {
32302     jj_la = xla; jj_lastpos = jj_scanpos = token;
32303     try { return !jj_3_51(); }
32304     catch(LookaheadSuccess ls) { return true; }
32305     finally { jj_save(50, xla); }
32306   }
32307 
32308   private boolean jj_2_52(int xla) {
32309     jj_la = xla; jj_lastpos = jj_scanpos = token;
32310     try { return !jj_3_52(); }
32311     catch(LookaheadSuccess ls) { return true; }
32312     finally { jj_save(51, xla); }
32313   }
32314 
32315   private boolean jj_2_53(int xla) {
32316     jj_la = xla; jj_lastpos = jj_scanpos = token;
32317     try { return !jj_3_53(); }
32318     catch(LookaheadSuccess ls) { return true; }
32319     finally { jj_save(52, xla); }
32320   }
32321 
32322   private boolean jj_2_54(int xla) {
32323     jj_la = xla; jj_lastpos = jj_scanpos = token;
32324     try { return !jj_3_54(); }
32325     catch(LookaheadSuccess ls) { return true; }
32326     finally { jj_save(53, xla); }
32327   }
32328 
32329   private boolean jj_2_55(int xla) {
32330     jj_la = xla; jj_lastpos = jj_scanpos = token;
32331     try { return !jj_3_55(); }
32332     catch(LookaheadSuccess ls) { return true; }
32333     finally { jj_save(54, xla); }
32334   }
32335 
32336   private boolean jj_2_56(int xla) {
32337     jj_la = xla; jj_lastpos = jj_scanpos = token;
32338     try { return !jj_3_56(); }
32339     catch(LookaheadSuccess ls) { return true; }
32340     finally { jj_save(55, xla); }
32341   }
32342 
32343   private boolean jj_2_57(int xla) {
32344     jj_la = xla; jj_lastpos = jj_scanpos = token;
32345     try { return !jj_3_57(); }
32346     catch(LookaheadSuccess ls) { return true; }
32347     finally { jj_save(56, xla); }
32348   }
32349 
32350   private boolean jj_2_58(int xla) {
32351     jj_la = xla; jj_lastpos = jj_scanpos = token;
32352     try { return !jj_3_58(); }
32353     catch(LookaheadSuccess ls) { return true; }
32354     finally { jj_save(57, xla); }
32355   }
32356 
32357   private boolean jj_2_59(int xla) {
32358     jj_la = xla; jj_lastpos = jj_scanpos = token;
32359     try { return !jj_3_59(); }
32360     catch(LookaheadSuccess ls) { return true; }
32361     finally { jj_save(58, xla); }
32362   }
32363 
32364   private boolean jj_2_60(int xla) {
32365     jj_la = xla; jj_lastpos = jj_scanpos = token;
32366     try { return !jj_3_60(); }
32367     catch(LookaheadSuccess ls) { return true; }
32368     finally { jj_save(59, xla); }
32369   }
32370 
32371   private boolean jj_2_61(int xla) {
32372     jj_la = xla; jj_lastpos = jj_scanpos = token;
32373     try { return !jj_3_61(); }
32374     catch(LookaheadSuccess ls) { return true; }
32375     finally { jj_save(60, xla); }
32376   }
32377 
32378   private boolean jj_2_62(int xla) {
32379     jj_la = xla; jj_lastpos = jj_scanpos = token;
32380     try { return !jj_3_62(); }
32381     catch(LookaheadSuccess ls) { return true; }
32382     finally { jj_save(61, xla); }
32383   }
32384 
32385   private boolean jj_2_63(int xla) {
32386     jj_la = xla; jj_lastpos = jj_scanpos = token;
32387     try { return !jj_3_63(); }
32388     catch(LookaheadSuccess ls) { return true; }
32389     finally { jj_save(62, xla); }
32390   }
32391 
32392   private boolean jj_2_64(int xla) {
32393     jj_la = xla; jj_lastpos = jj_scanpos = token;
32394     try { return !jj_3_64(); }
32395     catch(LookaheadSuccess ls) { return true; }
32396     finally { jj_save(63, xla); }
32397   }
32398 
32399   private boolean jj_2_65(int xla) {
32400     jj_la = xla; jj_lastpos = jj_scanpos = token;
32401     try { return !jj_3_65(); }
32402     catch(LookaheadSuccess ls) { return true; }
32403     finally { jj_save(64, xla); }
32404   }
32405 
32406   private boolean jj_2_66(int xla) {
32407     jj_la = xla; jj_lastpos = jj_scanpos = token;
32408     try { return !jj_3_66(); }
32409     catch(LookaheadSuccess ls) { return true; }
32410     finally { jj_save(65, xla); }
32411   }
32412 
32413   private boolean jj_2_67(int xla) {
32414     jj_la = xla; jj_lastpos = jj_scanpos = token;
32415     try { return !jj_3_67(); }
32416     catch(LookaheadSuccess ls) { return true; }
32417     finally { jj_save(66, xla); }
32418   }
32419 
32420   private boolean jj_2_68(int xla) {
32421     jj_la = xla; jj_lastpos = jj_scanpos = token;
32422     try { return !jj_3_68(); }
32423     catch(LookaheadSuccess ls) { return true; }
32424     finally { jj_save(67, xla); }
32425   }
32426 
32427   private boolean jj_2_69(int xla) {
32428     jj_la = xla; jj_lastpos = jj_scanpos = token;
32429     try { return !jj_3_69(); }
32430     catch(LookaheadSuccess ls) { return true; }
32431     finally { jj_save(68, xla); }
32432   }
32433 
32434   private boolean jj_2_70(int xla) {
32435     jj_la = xla; jj_lastpos = jj_scanpos = token;
32436     try { return !jj_3_70(); }
32437     catch(LookaheadSuccess ls) { return true; }
32438     finally { jj_save(69, xla); }
32439   }
32440 
32441   private boolean jj_2_71(int xla) {
32442     jj_la = xla; jj_lastpos = jj_scanpos = token;
32443     try { return !jj_3_71(); }
32444     catch(LookaheadSuccess ls) { return true; }
32445     finally { jj_save(70, xla); }
32446   }
32447 
32448   private boolean jj_2_72(int xla) {
32449     jj_la = xla; jj_lastpos = jj_scanpos = token;
32450     try { return !jj_3_72(); }
32451     catch(LookaheadSuccess ls) { return true; }
32452     finally { jj_save(71, xla); }
32453   }
32454 
32455   private boolean jj_2_73(int xla) {
32456     jj_la = xla; jj_lastpos = jj_scanpos = token;
32457     try { return !jj_3_73(); }
32458     catch(LookaheadSuccess ls) { return true; }
32459     finally { jj_save(72, xla); }
32460   }
32461 
32462   private boolean jj_2_74(int xla) {
32463     jj_la = xla; jj_lastpos = jj_scanpos = token;
32464     try { return !jj_3_74(); }
32465     catch(LookaheadSuccess ls) { return true; }
32466     finally { jj_save(73, xla); }
32467   }
32468 
32469   private boolean jj_2_75(int xla) {
32470     jj_la = xla; jj_lastpos = jj_scanpos = token;
32471     try { return !jj_3_75(); }
32472     catch(LookaheadSuccess ls) { return true; }
32473     finally { jj_save(74, xla); }
32474   }
32475 
32476   private boolean jj_2_76(int xla) {
32477     jj_la = xla; jj_lastpos = jj_scanpos = token;
32478     try { return !jj_3_76(); }
32479     catch(LookaheadSuccess ls) { return true; }
32480     finally { jj_save(75, xla); }
32481   }
32482 
32483   private boolean jj_2_77(int xla) {
32484     jj_la = xla; jj_lastpos = jj_scanpos = token;
32485     try { return !jj_3_77(); }
32486     catch(LookaheadSuccess ls) { return true; }
32487     finally { jj_save(76, xla); }
32488   }
32489 
32490   private boolean jj_2_78(int xla) {
32491     jj_la = xla; jj_lastpos = jj_scanpos = token;
32492     try { return !jj_3_78(); }
32493     catch(LookaheadSuccess ls) { return true; }
32494     finally { jj_save(77, xla); }
32495   }
32496 
32497   private boolean jj_2_79(int xla) {
32498     jj_la = xla; jj_lastpos = jj_scanpos = token;
32499     try { return !jj_3_79(); }
32500     catch(LookaheadSuccess ls) { return true; }
32501     finally { jj_save(78, xla); }
32502   }
32503 
32504   private boolean jj_2_80(int xla) {
32505     jj_la = xla; jj_lastpos = jj_scanpos = token;
32506     try { return !jj_3_80(); }
32507     catch(LookaheadSuccess ls) { return true; }
32508     finally { jj_save(79, xla); }
32509   }
32510 
32511   private boolean jj_2_81(int xla) {
32512     jj_la = xla; jj_lastpos = jj_scanpos = token;
32513     try { return !jj_3_81(); }
32514     catch(LookaheadSuccess ls) { return true; }
32515     finally { jj_save(80, xla); }
32516   }
32517 
32518   private boolean jj_2_82(int xla) {
32519     jj_la = xla; jj_lastpos = jj_scanpos = token;
32520     try { return !jj_3_82(); }
32521     catch(LookaheadSuccess ls) { return true; }
32522     finally { jj_save(81, xla); }
32523   }
32524 
32525   private boolean jj_2_83(int xla) {
32526     jj_la = xla; jj_lastpos = jj_scanpos = token;
32527     try { return !jj_3_83(); }
32528     catch(LookaheadSuccess ls) { return true; }
32529     finally { jj_save(82, xla); }
32530   }
32531 
32532   private boolean jj_3_80() {
32533     if (jj_3R_151()) return true;
32534     return false;
32535   }
32536 
32537   private boolean jj_3_79() {
32538     if (jj_3R_118()) return true;
32539     return false;
32540   }
32541 
32542   private boolean jj_3R_175() {
32543     if (jj_3R_266()) return true;
32544     return false;
32545   }
32546 
32547   private boolean jj_3R_621() {
32548     if (jj_scan_token(3)) return true;
32549     Token xsp;
32550     xsp = jj_scanpos;
32551     if (jj_scan_token(417)) {
32552     jj_scanpos = xsp;
32553     if (jj_scan_token(425)) {
32554     jj_scanpos = xsp;
32555     if (jj_3R_622()) return true;
32556     }
32557     }
32558     return false;
32559   }
32560 
32561   private boolean jj_3R_593() {
32562     if (jj_scan_token(9)) return true;
32563     if (jj_scan_token(10)) return true;
32564     return false;
32565   }
32566 
32567   private boolean jj_3R_288() {
32568     if (jj_scan_token(PARAMETERS)) return true;
32569     if (jj_3R_558()) return true;
32570     return false;
32571   }
32572 
32573   private boolean jj_3R_560() {
32574     Token xsp;
32575     xsp = jj_scanpos;
32576     if (jj_3R_593()) {
32577     jj_scanpos = xsp;
32578     if (jj_scan_token(91)) return true;
32579     }
32580     if (jj_3R_232()) return true;
32581     return false;
32582   }
32583 
32584   private boolean jj_3R_520() {
32585     if (jj_scan_token(5)) return true;
32586     if (jj_3R_126()) return true;
32587     if (jj_scan_token(7)) return true;
32588     return false;
32589   }
32590 
32591   private boolean jj_3R_287() {
32592     if (jj_scan_token(WITH)) return true;
32593     if (jj_scan_token(CONTEXT)) return true;
32594     return false;
32595   }
32596 
32597   private boolean jj_3R_150() {
32598     if (jj_scan_token(6)) return true;
32599     if (jj_3R_123()) return true;
32600     return false;
32601   }
32602 
32603   private boolean jj_3R_286() {
32604     if (jj_scan_token(NAME)) return true;
32605     Token xsp;
32606     xsp = jj_scanpos;
32607     if (jj_scan_token(417)) {
32608     jj_scanpos = xsp;
32609     if (jj_scan_token(425)) {
32610     jj_scanpos = xsp;
32611     if (jj_3R_557()) return true;
32612     }
32613     }
32614     return false;
32615   }
32616 
32617   private boolean jj_3R_522() {
32618     if (jj_scan_token(INDEX)) return true;
32619     if (jj_scan_token(BY)) return true;
32620     if (jj_3R_234()) return true;
32621     return false;
32622   }
32623 
32624   private boolean jj_3R_518() {
32625     if (jj_scan_token(6)) return true;
32626     if (jj_3R_516()) return true;
32627     return false;
32628   }
32629 
32630   private boolean jj_3R_199() {
32631     Token xsp;
32632     xsp = jj_scanpos;
32633     if (jj_3R_285()) {
32634     jj_scanpos = xsp;
32635     if (jj_3R_286()) {
32636     jj_scanpos = xsp;
32637     if (jj_3R_287()) {
32638     jj_scanpos = xsp;
32639     if (jj_3R_288()) return true;
32640     }
32641     }
32642     }
32643     return false;
32644   }
32645 
32646   private boolean jj_3R_285() {
32647     if (jj_scan_token(LIBRARY)) return true;
32648     Token xsp;
32649     xsp = jj_scanpos;
32650     if (jj_scan_token(417)) {
32651     jj_scanpos = xsp;
32652     if (jj_scan_token(425)) {
32653     jj_scanpos = xsp;
32654     if (jj_3R_556()) return true;
32655     }
32656     }
32657     xsp = jj_scanpos;
32658     if (jj_3R_621()) jj_scanpos = xsp;
32659     return false;
32660   }
32661 
32662   private boolean jj_3R_149() {
32663     if (jj_scan_token(6)) return true;
32664     if (jj_3R_123()) return true;
32665     return false;
32666   }
32667 
32668   private boolean jj_3R_517() {
32669     if (jj_scan_token(6)) return true;
32670     if (jj_3R_516()) return true;
32671     return false;
32672   }
32673 
32674   private boolean jj_3R_198() {
32675     if (jj_scan_token(LANGUAGE)) return true;
32676     Token xsp;
32677     xsp = jj_scanpos;
32678     if (jj_scan_token(417)) {
32679     jj_scanpos = xsp;
32680     if (jj_scan_token(152)) return true;
32681     }
32682     return false;
32683   }
32684 
32685   private boolean jj_3R_559() {
32686     Token xsp;
32687     xsp = jj_scanpos;
32688     if (jj_scan_token(181)) jj_scanpos = xsp;
32689     if (jj_scan_token(NULL)) return true;
32690     return false;
32691   }
32692 
32693   private boolean jj_3R_524() {
32694     if (jj_scan_token(6)) return true;
32695     if (jj_3R_232()) return true;
32696     return false;
32697   }
32698 
32699   private boolean jj_3R_519() {
32700     if (jj_scan_token(VARYING)) return true;
32701     if (jj_scan_token(ARRAY)) return true;
32702     return false;
32703   }
32704 
32705   private boolean jj_3_74() {
32706     if (jj_3R_123()) return true;
32707     if (jj_scan_token(3)) return true;
32708     return false;
32709   }
32710 
32711   private boolean jj_3_77() {
32712     if (jj_3R_123()) return true;
32713     if (jj_scan_token(3)) return true;
32714     return false;
32715   }
32716 
32717   private boolean jj_3R_523() {
32718     if (jj_scan_token(RETURN)) return true;
32719     if (jj_3R_234()) return true;
32720     return false;
32721   }
32722 
32723   private boolean jj_3R_521() {
32724     if (jj_scan_token(NOT)) return true;
32725     if (jj_scan_token(NULL)) return true;
32726     return false;
32727   }
32728 
32729   private boolean jj_3_73() {
32730     if (jj_scan_token(OF)) return true;
32731     if (jj_3R_123()) return true;
32732     Token xsp;
32733     while (true) {
32734       xsp = jj_scanpos;
32735       if (jj_3R_150()) { jj_scanpos = xsp; break; }
32736     }
32737     return false;
32738   }
32739 
32740   private boolean jj_3R_122() {
32741     Token xsp;
32742     xsp = jj_scanpos;
32743     if (jj_scan_token(113)) {
32744     jj_scanpos = xsp;
32745     if (jj_3R_198()) return true;
32746     }
32747     while (true) {
32748       xsp = jj_scanpos;
32749       if (jj_3R_199()) { jj_scanpos = xsp; break; }
32750     }
32751     return false;
32752   }
32753 
32754   private boolean jj_3R_493() {
32755     if (jj_3R_234()) return true;
32756     return false;
32757   }
32758 
32759   private boolean jj_3_72() {
32760     if (jj_scan_token(OF)) return true;
32761     if (jj_3R_123()) return true;
32762     Token xsp;
32763     while (true) {
32764       xsp = jj_scanpos;
32765       if (jj_3R_149()) { jj_scanpos = xsp; break; }
32766     }
32767     return false;
32768   }
32769 
32770   private boolean jj_3R_492() {
32771     if (jj_scan_token(5)) return true;
32772     if (jj_3R_232()) return true;
32773     Token xsp;
32774     while (true) {
32775       xsp = jj_scanpos;
32776       if (jj_3R_524()) { jj_scanpos = xsp; break; }
32777     }
32778     if (jj_scan_token(7)) return true;
32779     return false;
32780   }
32781 
32782   private boolean jj_3R_491() {
32783     if (jj_scan_token(REF)) return true;
32784     if (jj_scan_token(CURSOR)) return true;
32785     Token xsp;
32786     xsp = jj_scanpos;
32787     if (jj_3R_523()) jj_scanpos = xsp;
32788     return false;
32789   }
32790 
32791   private boolean jj_3R_516() {
32792     if (jj_3R_123()) return true;
32793     if (jj_3R_234()) return true;
32794     Token xsp;
32795     xsp = jj_scanpos;
32796     if (jj_3R_559()) jj_scanpos = xsp;
32797     xsp = jj_scanpos;
32798     if (jj_3R_560()) jj_scanpos = xsp;
32799     return false;
32800   }
32801 
32802   private boolean jj_3R_490() {
32803     Token xsp;
32804     xsp = jj_scanpos;
32805     if (jj_scan_token(268)) {
32806     jj_scanpos = xsp;
32807     if (jj_scan_token(307)) {
32808     jj_scanpos = xsp;
32809     if (jj_3R_519()) return true;
32810     }
32811     }
32812     xsp = jj_scanpos;
32813     if (jj_3R_520()) jj_scanpos = xsp;
32814     if (jj_scan_token(OF)) return true;
32815     if (jj_3R_234()) return true;
32816     xsp = jj_scanpos;
32817     if (jj_3R_521()) jj_scanpos = xsp;
32818     xsp = jj_scanpos;
32819     if (jj_3R_522()) jj_scanpos = xsp;
32820     return false;
32821   }
32822 
32823   private boolean jj_3R_489() {
32824     if (jj_scan_token(RECORD)) return true;
32825     if (jj_scan_token(5)) return true;
32826     if (jj_3R_516()) return true;
32827     Token xsp;
32828     while (true) {
32829       xsp = jj_scanpos;
32830       if (jj_3R_518()) { jj_scanpos = xsp; break; }
32831     }
32832     if (jj_scan_token(7)) return true;
32833     return false;
32834   }
32835 
32836   private boolean jj_3R_488() {
32837     if (jj_scan_token(OBJECT)) return true;
32838     if (jj_scan_token(5)) return true;
32839     if (jj_3R_516()) return true;
32840     Token xsp;
32841     while (true) {
32842       xsp = jj_scanpos;
32843       if (jj_3R_517()) { jj_scanpos = xsp; break; }
32844     }
32845     if (jj_scan_token(7)) return true;
32846     return false;
32847   }
32848 
32849   private boolean jj_3R_265() {
32850     Token xsp;
32851     xsp = jj_scanpos;
32852     if (jj_scan_token(99)) {
32853     jj_scanpos = xsp;
32854     if (jj_scan_token(180)) return true;
32855     }
32856     return false;
32857   }
32858 
32859   private boolean jj_3R_630() {
32860     if (jj_3R_172()) return true;
32861     return false;
32862   }
32863 
32864   private boolean jj_3_44() {
32865     if (jj_scan_token(NEW)) return true;
32866     Token xsp;
32867     xsp = jj_scanpos;
32868     if (jj_scan_token(67)) {
32869     jj_scanpos = xsp;
32870     if (jj_scan_token(189)) {
32871     jj_scanpos = xsp;
32872     if (jj_scan_token(188)) {
32873     jj_scanpos = xsp;
32874     if (jj_scan_token(187)) {
32875     jj_scanpos = xsp;
32876     if (jj_scan_token(186)) {
32877     jj_scanpos = xsp;
32878     if (jj_scan_token(190)) return true;
32879     }
32880     }
32881     }
32882     }
32883     }
32884     return false;
32885   }
32886 
32887   private boolean jj_3R_267() {
32888     Token xsp;
32889     xsp = jj_scanpos;
32890     if (jj_scan_token(92)) {
32891     jj_scanpos = xsp;
32892     if (jj_scan_token(142)) {
32893     jj_scanpos = xsp;
32894     if (jj_scan_token(294)) return true;
32895     }
32896     }
32897     return false;
32898   }
32899 
32900   private boolean jj_3_75() {
32901     if (jj_3R_123()) return true;
32902     if (jj_scan_token(3)) return true;
32903     return false;
32904   }
32905 
32906   private boolean jj_3R_177() {
32907     Token xsp;
32908     xsp = jj_scanpos;
32909     if (jj_3_75()) jj_scanpos = xsp;
32910     if (jj_3R_123()) return true;
32911     return false;
32912   }
32913 
32914   private boolean jj_3_76() {
32915     if (jj_scan_token(NESTED)) return true;
32916     if (jj_scan_token(TABLE)) return true;
32917     return false;
32918   }
32919 
32920   private boolean jj_3R_176() {
32921     if (jj_scan_token(OR)) return true;
32922     Token xsp;
32923     xsp = jj_scanpos;
32924     if (jj_3R_267()) {
32925     jj_scanpos = xsp;
32926     if (jj_3R_268()) return true;
32927     }
32928     return false;
32929   }
32930 
32931   private boolean jj_3R_174() {
32932     Token xsp;
32933     xsp = jj_scanpos;
32934     if (jj_scan_token(92)) {
32935     jj_scanpos = xsp;
32936     if (jj_scan_token(142)) {
32937     jj_scanpos = xsp;
32938     if (jj_scan_token(294)) return true;
32939     }
32940     }
32941     xsp = jj_scanpos;
32942     if (jj_3_72()) jj_scanpos = xsp;
32943     return false;
32944   }
32945 
32946   private boolean jj_3R_589() {
32947     if (jj_3R_172()) return true;
32948     return false;
32949   }
32950 
32951   private boolean jj_3R_264() {
32952     if (jj_scan_token(OR)) return true;
32953     if (jj_scan_token(REPLACE)) return true;
32954     return false;
32955   }
32956 
32957   private boolean jj_3R_487() {
32958     if (jj_scan_token(NOT)) return true;
32959     if (jj_scan_token(NULL)) return true;
32960     return false;
32961   }
32962 
32963   private boolean jj_3R_515() {
32964     if (jj_scan_token(RANGE)) return true;
32965     if (jj_3R_478()) return true;
32966     if (jj_scan_token(12)) return true;
32967     if (jj_3R_478()) return true;
32968     return false;
32969   }
32970 
32971   private boolean jj_3R_514() {
32972     if (jj_scan_token(5)) return true;
32973     if (jj_scan_token(IDENTIFIER)) return true;
32974     if (jj_scan_token(7)) return true;
32975     return false;
32976   }
32977 
32978   private boolean jj_3R_486() {
32979     Token xsp;
32980     xsp = jj_scanpos;
32981     if (jj_3R_514()) {
32982     jj_scanpos = xsp;
32983     if (jj_3R_515()) return true;
32984     }
32985     return false;
32986   }
32987 
32988   private boolean jj_3R_631() {
32989     if (jj_scan_token(IN)) return true;
32990     Token xsp;
32991     xsp = jj_scanpos;
32992     if (jj_scan_token(204)) jj_scanpos = xsp;
32993     return false;
32994   }
32995 
32996   private boolean jj_3R_629() {
32997     Token xsp;
32998     xsp = jj_scanpos;
32999     if (jj_3R_631()) {
33000     jj_scanpos = xsp;
33001     if (jj_scan_token(204)) return true;
33002     }
33003     return false;
33004   }
33005 
33006   private boolean jj_3R_242() {
33007     if (jj_scan_token(TYPE)) return true;
33008     if (jj_3R_119()) return true;
33009     Token xsp;
33010     xsp = jj_scanpos;
33011     if (jj_scan_token(150)) {
33012     jj_scanpos = xsp;
33013     if (jj_scan_token(50)) return true;
33014     }
33015     xsp = jj_scanpos;
33016     if (jj_3_44()) {
33017     jj_scanpos = xsp;
33018     if (jj_3R_488()) {
33019     jj_scanpos = xsp;
33020     if (jj_3R_489()) {
33021     jj_scanpos = xsp;
33022     if (jj_3R_490()) {
33023     jj_scanpos = xsp;
33024     if (jj_3R_491()) {
33025     jj_scanpos = xsp;
33026     if (jj_3R_492()) {
33027     jj_scanpos = xsp;
33028     if (jj_3R_493()) return true;
33029     }
33030     }
33031     }
33032     }
33033     }
33034     }
33035     return false;
33036   }
33037 
33038   private boolean jj_3R_173() {
33039     if (jj_scan_token(CREATE)) return true;
33040     Token xsp;
33041     xsp = jj_scanpos;
33042     if (jj_3R_264()) jj_scanpos = xsp;
33043     xsp = jj_scanpos;
33044     if (jj_3R_265()) jj_scanpos = xsp;
33045     return false;
33046   }
33047 
33048   private boolean jj_3R_626() {
33049     if (jj_scan_token(6)) return true;
33050     if (jj_3R_232()) return true;
33051     return false;
33052   }
33053 
33054   private boolean jj_3R_625() {
33055     if (jj_scan_token(6)) return true;
33056     Token xsp;
33057     xsp = jj_scanpos;
33058     if (jj_3R_629()) jj_scanpos = xsp;
33059     if (jj_3R_232()) return true;
33060     return false;
33061   }
33062 
33063   private boolean jj_3R_107() {
33064     Token xsp;
33065     xsp = jj_scanpos;
33066     if (jj_3R_173()) jj_scanpos = xsp;
33067     if (jj_scan_token(TRIGGER)) return true;
33068     if (jj_3R_153()) return true;
33069     xsp = jj_scanpos;
33070     if (jj_scan_token(319)) {
33071     jj_scanpos = xsp;
33072     if (jj_scan_token(318)) {
33073     jj_scanpos = xsp;
33074     if (jj_scan_token(320)) {
33075     jj_scanpos = xsp;
33076     if (jj_scan_token(120)) return true;
33077     }
33078     }
33079     }
33080     xsp = jj_scanpos;
33081     if (jj_3R_174()) {
33082     jj_scanpos = xsp;
33083     if (jj_3R_175()) return true;
33084     }
33085     while (true) {
33086       xsp = jj_scanpos;
33087       if (jj_3R_176()) { jj_scanpos = xsp; break; }
33088     }
33089     if (jj_scan_token(ON)) return true;
33090     xsp = jj_scanpos;
33091     if (jj_scan_token(345)) {
33092     jj_scanpos = xsp;
33093     if (jj_3_76()) {
33094     jj_scanpos = xsp;
33095     if (jj_3R_177()) return true;
33096     }
33097     }
33098     return false;
33099   }
33100 
33101   private boolean jj_3R_241() {
33102     if (jj_scan_token(SUBTYPE)) return true;
33103     if (jj_3R_119()) return true;
33104     if (jj_scan_token(IS)) return true;
33105     if (jj_3R_234()) return true;
33106     Token xsp;
33107     xsp = jj_scanpos;
33108     if (jj_3R_486()) jj_scanpos = xsp;
33109     xsp = jj_scanpos;
33110     if (jj_3R_487()) jj_scanpos = xsp;
33111     return false;
33112   }
33113 
33114   private boolean jj_3R_613() {
33115     if (jj_3R_172()) return true;
33116     return false;
33117   }
33118 
33119   private boolean jj_3R_151() {
33120     Token xsp;
33121     xsp = jj_scanpos;
33122     if (jj_3R_241()) {
33123     jj_scanpos = xsp;
33124     if (jj_3R_242()) return true;
33125     }
33126     if (jj_scan_token(4)) return true;
33127     return false;
33128   }
33129 
33130   private boolean jj_3R_550() {
33131     if (jj_scan_token(LIMIT)) return true;
33132     if (jj_3R_232()) return true;
33133     return false;
33134   }
33135 
33136   private boolean jj_3R_628() {
33137     if (jj_scan_token(6)) return true;
33138     if (jj_3R_232()) return true;
33139     return false;
33140   }
33141 
33142   private boolean jj_3R_591() {
33143     if (jj_scan_token(CC_ELSE)) return true;
33144     Token xsp;
33145     if (jj_3R_613()) return true;
33146     while (true) {
33147       xsp = jj_scanpos;
33148       if (jj_3R_613()) { jj_scanpos = xsp; break; }
33149     }
33150     return false;
33151   }
33152 
33153   private boolean jj_3R_590() {
33154     if (jj_scan_token(CC_ELSIF)) return true;
33155     if (jj_3R_342()) return true;
33156     if (jj_scan_token(CC_THEN)) return true;
33157     Token xsp;
33158     if (jj_3R_630()) return true;
33159     while (true) {
33160       xsp = jj_scanpos;
33161       if (jj_3R_630()) { jj_scanpos = xsp; break; }
33162     }
33163     return false;
33164   }
33165 
33166   private boolean jj_3R_452() {
33167     if (jj_scan_token(CC_ERROR)) return true;
33168     if (jj_3R_232()) return true;
33169     if (jj_scan_token(CC_END)) return true;
33170     return false;
33171   }
33172 
33173   private boolean jj_3R_451() {
33174     if (jj_scan_token(CC_IF)) return true;
33175     if (jj_3R_342()) return true;
33176     if (jj_scan_token(CC_THEN)) return true;
33177     Token xsp;
33178     while (true) {
33179       xsp = jj_scanpos;
33180       if (jj_3R_589()) { jj_scanpos = xsp; break; }
33181     }
33182     while (true) {
33183       xsp = jj_scanpos;
33184       if (jj_3R_590()) { jj_scanpos = xsp; break; }
33185     }
33186     while (true) {
33187       xsp = jj_scanpos;
33188       if (jj_3R_591()) { jj_scanpos = xsp; break; }
33189     }
33190     if (jj_scan_token(CC_END)) return true;
33191     return false;
33192   }
33193 
33194   private boolean jj_3R_624() {
33195     if (jj_scan_token(6)) return true;
33196     if (jj_3R_293()) return true;
33197     return false;
33198   }
33199 
33200   private boolean jj_3R_416() {
33201     Token xsp;
33202     xsp = jj_scanpos;
33203     if (jj_3R_451()) {
33204     jj_scanpos = xsp;
33205     if (jj_3R_452()) return true;
33206     }
33207     return false;
33208   }
33209 
33210   private boolean jj_3R_612() {
33211     if (jj_scan_token(IN)) return true;
33212     Token xsp;
33213     xsp = jj_scanpos;
33214     if (jj_scan_token(204)) jj_scanpos = xsp;
33215     return false;
33216   }
33217 
33218   private boolean jj_3R_588() {
33219     Token xsp;
33220     xsp = jj_scanpos;
33221     if (jj_3R_612()) {
33222     jj_scanpos = xsp;
33223     if (jj_scan_token(204)) return true;
33224     }
33225     return false;
33226   }
33227 
33228   private boolean jj_3R_548() {
33229     if (jj_scan_token(BULK)) return true;
33230     if (jj_scan_token(COLLECT)) return true;
33231     return false;
33232   }
33233 
33234   private boolean jj_3R_549() {
33235     if (jj_scan_token(6)) return true;
33236     if (jj_3R_232()) return true;
33237     return false;
33238   }
33239 
33240   private boolean jj_3R_415() {
33241     if (jj_scan_token(PIPE)) return true;
33242     if (jj_scan_token(ROW)) return true;
33243     if (jj_3R_232()) return true;
33244     return false;
33245   }
33246 
33247   private boolean jj_3R_587() {
33248     if (jj_scan_token(USING)) return true;
33249     if (jj_3R_232()) return true;
33250     Token xsp;
33251     while (true) {
33252       xsp = jj_scanpos;
33253       if (jj_3R_628()) { jj_scanpos = xsp; break; }
33254     }
33255     return false;
33256   }
33257 
33258   private boolean jj_3R_553() {
33259     Token xsp;
33260     xsp = jj_scanpos;
33261     if (jj_scan_token(234)) {
33262     jj_scanpos = xsp;
33263     if (jj_scan_token(235)) return true;
33264     }
33265     if (jj_scan_token(INTO)) return true;
33266     if (jj_3R_232()) return true;
33267     while (true) {
33268       xsp = jj_scanpos;
33269       if (jj_3R_626()) { jj_scanpos = xsp; break; }
33270     }
33271     return false;
33272   }
33273 
33274   private boolean jj_3R_552() {
33275     if (jj_scan_token(USING)) return true;
33276     Token xsp;
33277     xsp = jj_scanpos;
33278     if (jj_3R_588()) jj_scanpos = xsp;
33279     if (jj_3R_232()) return true;
33280     while (true) {
33281       xsp = jj_scanpos;
33282       if (jj_3R_625()) { jj_scanpos = xsp; break; }
33283     }
33284     return false;
33285   }
33286 
33287   private boolean jj_3R_551() {
33288     if (jj_scan_token(INTO)) return true;
33289     if (jj_3R_293()) return true;
33290     Token xsp;
33291     while (true) {
33292       xsp = jj_scanpos;
33293       if (jj_3R_624()) { jj_scanpos = xsp; break; }
33294     }
33295     return false;
33296   }
33297 
33298   private boolean jj_3R_447() {
33299     if (jj_scan_token(WHEN)) return true;
33300     if (jj_3R_232()) return true;
33301     return false;
33302   }
33303 
33304   private boolean jj_3R_414() {
33305     if (jj_scan_token(EXECUTE)) return true;
33306     if (jj_scan_token(IMMEDIATE)) return true;
33307     if (jj_3R_232()) return true;
33308     Token xsp;
33309     xsp = jj_scanpos;
33310     if (jj_3R_551()) jj_scanpos = xsp;
33311     xsp = jj_scanpos;
33312     if (jj_3R_552()) jj_scanpos = xsp;
33313     xsp = jj_scanpos;
33314     if (jj_3R_553()) jj_scanpos = xsp;
33315     if (jj_scan_token(4)) return true;
33316     return false;
33317   }
33318 
33319   private boolean jj_3R_450() {
33320     if (jj_scan_token(FOR)) return true;
33321     if (jj_3R_232()) return true;
33322     Token xsp;
33323     xsp = jj_scanpos;
33324     if (jj_3R_587()) jj_scanpos = xsp;
33325     return false;
33326   }
33327 
33328   private boolean jj_3R_413() {
33329     if (jj_scan_token(FETCH)) return true;
33330     if (jj_3R_127()) return true;
33331     Token xsp;
33332     xsp = jj_scanpos;
33333     if (jj_3R_548()) jj_scanpos = xsp;
33334     if (jj_scan_token(INTO)) return true;
33335     if (jj_3R_232()) return true;
33336     while (true) {
33337       xsp = jj_scanpos;
33338       if (jj_3R_549()) { jj_scanpos = xsp; break; }
33339     }
33340     xsp = jj_scanpos;
33341     if (jj_3R_550()) jj_scanpos = xsp;
33342     return false;
33343   }
33344 
33345   private boolean jj_3R_207() {
33346     if (jj_scan_token(WHEN)) return true;
33347     if (jj_3R_232()) return true;
33348     return false;
33349   }
33350 
33351   private boolean jj_3R_449() {
33352     if (jj_3R_232()) return true;
33353     return false;
33354   }
33355 
33356   private boolean jj_3R_412() {
33357     if (jj_scan_token(OPEN)) return true;
33358     Token xsp;
33359     xsp = jj_scanpos;
33360     if (jj_3R_449()) jj_scanpos = xsp;
33361     xsp = jj_scanpos;
33362     if (jj_3R_450()) jj_scanpos = xsp;
33363     return false;
33364   }
33365 
33366   private boolean jj_3R_399() {
33367     if (jj_scan_token(INTERFACE)) return true;
33368     if (jj_scan_token(5)) return true;
33369     return false;
33370   }
33371 
33372   private boolean jj_3R_398() {
33373     if (jj_scan_token(EXCEPTION_INIT)) return true;
33374     if (jj_scan_token(5)) return true;
33375     return false;
33376   }
33377 
33378   private boolean jj_3R_397() {
33379     if (jj_scan_token(RESTRICT_REFERENCES)) return true;
33380     if (jj_scan_token(5)) return true;
33381     return false;
33382   }
33383 
33384   private boolean jj_3R_448() {
33385     if (jj_3R_127()) return true;
33386     return false;
33387   }
33388 
33389   private boolean jj_3R_411() {
33390     if (jj_scan_token(CLOSE)) return true;
33391     if (jj_3R_127()) return true;
33392     return false;
33393   }
33394 
33395   private boolean jj_3R_446() {
33396     if (jj_3R_141()) return true;
33397     return false;
33398   }
33399 
33400   private boolean jj_3R_410() {
33401     if (jj_scan_token(RAISE)) return true;
33402     Token xsp;
33403     xsp = jj_scanpos;
33404     if (jj_3R_448()) jj_scanpos = xsp;
33405     return false;
33406   }
33407 
33408   private boolean jj_3R_206() {
33409     if (jj_3R_141()) return true;
33410     return false;
33411   }
33412 
33413   private boolean jj_3R_349() {
33414     if (jj_scan_token(PRAGMA)) return true;
33415     Token xsp;
33416     xsp = jj_scanpos;
33417     if (jj_scan_token(38)) {
33418     jj_scanpos = xsp;
33419     if (jj_scan_token(41)) {
33420     jj_scanpos = xsp;
33421     if (jj_3R_397()) {
33422     jj_scanpos = xsp;
33423     if (jj_3R_398()) {
33424     jj_scanpos = xsp;
33425     if (jj_3R_399()) return true;
33426     }
33427     }
33428     }
33429     }
33430     return false;
33431   }
33432 
33433   private boolean jj_3R_586() {
33434     if (jj_scan_token(12)) return true;
33435     if (jj_3R_232()) return true;
33436     return false;
33437   }
33438 
33439   private boolean jj_3R_409() {
33440     if (jj_scan_token(EXIT)) return true;
33441     Token xsp;
33442     xsp = jj_scanpos;
33443     if (jj_3R_446()) jj_scanpos = xsp;
33444     xsp = jj_scanpos;
33445     if (jj_3R_447()) jj_scanpos = xsp;
33446     return false;
33447   }
33448 
33449   private boolean jj_3R_445() {
33450     if (jj_3R_232()) return true;
33451     return false;
33452   }
33453 
33454   private boolean jj_3R_131() {
33455     if (jj_scan_token(CONTINUE)) return true;
33456     Token xsp;
33457     xsp = jj_scanpos;
33458     if (jj_3R_206()) jj_scanpos = xsp;
33459     xsp = jj_scanpos;
33460     if (jj_3R_207()) jj_scanpos = xsp;
33461     return false;
33462   }
33463 
33464   private boolean jj_3R_546() {
33465     if (jj_scan_token(SAVE)) return true;
33466     if (jj_scan_token(EXCEPTIONS)) return true;
33467     return false;
33468   }
33469 
33470   private boolean jj_3R_545() {
33471     if (jj_3R_232()) return true;
33472     Token xsp;
33473     xsp = jj_scanpos;
33474     if (jj_3R_586()) jj_scanpos = xsp;
33475     return false;
33476   }
33477 
33478   private boolean jj_3R_623() {
33479     if (jj_3R_172()) return true;
33480     return false;
33481   }
33482 
33483   private boolean jj_3R_544() {
33484     Token xsp;
33485     xsp = jj_scanpos;
33486     if (jj_scan_token(138)) {
33487     jj_scanpos = xsp;
33488     if (jj_scan_token(286)) return true;
33489     }
33490     if (jj_scan_token(OF)) return true;
33491     if (jj_3R_232()) return true;
33492     return false;
33493   }
33494 
33495   private boolean jj_3R_408() {
33496     if (jj_scan_token(RETURN)) return true;
33497     Token xsp;
33498     xsp = jj_scanpos;
33499     if (jj_3R_445()) jj_scanpos = xsp;
33500     return false;
33501   }
33502 
33503   private boolean jj_3R_146() {
33504     if (jj_3R_123()) return true;
33505     if (jj_3R_234()) return true;
33506     return false;
33507   }
33508 
33509   private boolean jj_3R_407() {
33510     if (jj_scan_token(GOTO)) return true;
33511     if (jj_3R_127()) return true;
33512     return false;
33513   }
33514 
33515   private boolean jj_3R_404() {
33516     if (jj_scan_token(FORALL)) return true;
33517     if (jj_3R_443()) return true;
33518     if (jj_scan_token(IN)) return true;
33519     Token xsp;
33520     xsp = jj_scanpos;
33521     if (jj_3R_544()) {
33522     jj_scanpos = xsp;
33523     if (jj_3R_545()) return true;
33524     }
33525     xsp = jj_scanpos;
33526     if (jj_3R_546()) jj_scanpos = xsp;
33527     if (jj_3R_400()) return true;
33528     return false;
33529   }
33530 
33531   private boolean jj_3R_543() {
33532     if (jj_scan_token(12)) return true;
33533     if (jj_3R_232()) return true;
33534     return false;
33535   }
33536 
33537   private boolean jj_3R_540() {
33538     if (jj_3R_172()) return true;
33539     return false;
33540   }
33541 
33542   private boolean jj_3R_547() {
33543     if (jj_3R_172()) return true;
33544     return false;
33545   }
33546 
33547   private boolean jj_3R_443() {
33548     if (jj_3R_123()) return true;
33549     return false;
33550   }
33551 
33552   private boolean jj_3R_442() {
33553     if (jj_3R_123()) return true;
33554     return false;
33555   }
33556 
33557   private boolean jj_3R_542() {
33558     if (jj_3R_480()) return true;
33559     return false;
33560   }
33561 
33562   private boolean jj_3R_541() {
33563     if (jj_3R_585()) return true;
33564     return false;
33565   }
33566 
33567   private boolean jj_3R_402() {
33568     if (jj_scan_token(IF)) return true;
33569     if (jj_3R_232()) return true;
33570     if (jj_scan_token(THEN)) return true;
33571     Token xsp;
33572     if (jj_3R_540()) return true;
33573     while (true) {
33574       xsp = jj_scanpos;
33575       if (jj_3R_540()) { jj_scanpos = xsp; break; }
33576     }
33577     while (true) {
33578       xsp = jj_scanpos;
33579       if (jj_3R_541()) { jj_scanpos = xsp; break; }
33580     }
33581     xsp = jj_scanpos;
33582     if (jj_3R_542()) jj_scanpos = xsp;
33583     if (jj_scan_token(END)) return true;
33584     if (jj_scan_token(IF)) return true;
33585     return false;
33586   }
33587 
33588   private boolean jj_3R_353() {
33589     if (jj_scan_token(CASCADE)) return true;
33590     return false;
33591   }
33592 
33593   private boolean jj_3R_627() {
33594     if (jj_3R_172()) return true;
33595     return false;
33596   }
33597 
33598   private boolean jj_3R_313() {
33599     Token xsp;
33600     xsp = jj_scanpos;
33601     if (jj_scan_token(149)) {
33602     jj_scanpos = xsp;
33603     if (jj_3R_353()) return true;
33604     }
33605     return false;
33606   }
33607 
33608   private boolean jj_3R_130() {
33609     if (jj_scan_token(LOCK)) return true;
33610     if (jj_scan_token(TABLE)) return true;
33611     return false;
33612   }
33613 
33614   private boolean jj_3R_406() {
33615     if (jj_scan_token(WHILE)) return true;
33616     if (jj_3R_232()) return true;
33617     if (jj_scan_token(LOOP)) return true;
33618     Token xsp;
33619     if (jj_3R_547()) return true;
33620     while (true) {
33621       xsp = jj_scanpos;
33622       if (jj_3R_547()) { jj_scanpos = xsp; break; }
33623     }
33624     if (jj_scan_token(END)) return true;
33625     if (jj_scan_token(LOOP)) return true;
33626     xsp = jj_scanpos;
33627     if (jj_scan_token(417)) jj_scanpos = xsp;
33628     return false;
33629   }
33630 
33631   private boolean jj_3R_148() {
33632     if (jj_3R_237()) return true;
33633     return false;
33634   }
33635 
33636   private boolean jj_3_71() {
33637     if (jj_3R_145()) return true;
33638     return false;
33639   }
33640 
33641   private boolean jj_3R_147() {
33642     if (jj_scan_token(AUTHID)) return true;
33643     Token xsp;
33644     xsp = jj_scanpos;
33645     if (jj_scan_token(37)) {
33646     jj_scanpos = xsp;
33647     if (jj_scan_token(36)) return true;
33648     }
33649     return false;
33650   }
33651 
33652   private boolean jj_3R_403() {
33653     if (jj_scan_token(FOR)) return true;
33654     if (jj_3R_442()) return true;
33655     if (jj_scan_token(IN)) return true;
33656     Token xsp;
33657     xsp = jj_scanpos;
33658     if (jj_scan_token(236)) jj_scanpos = xsp;
33659     if (jj_3R_232()) return true;
33660     xsp = jj_scanpos;
33661     if (jj_3R_543()) jj_scanpos = xsp;
33662     if (jj_scan_token(LOOP)) return true;
33663     if (jj_3R_623()) return true;
33664     while (true) {
33665       xsp = jj_scanpos;
33666       if (jj_3R_623()) { jj_scanpos = xsp; break; }
33667     }
33668     if (jj_scan_token(END)) return true;
33669     if (jj_scan_token(LOOP)) return true;
33670     xsp = jj_scanpos;
33671     if (jj_scan_token(417)) jj_scanpos = xsp;
33672     return false;
33673   }
33674 
33675   private boolean jj_3R_610() {
33676     if (jj_3R_172()) return true;
33677     return false;
33678   }
33679 
33680   private boolean jj_3R_444() {
33681     if (jj_3R_172()) return true;
33682     return false;
33683   }
33684 
33685   private boolean jj_3R_312() {
33686     Token xsp;
33687     xsp = jj_scanpos;
33688     if (jj_scan_token(181)) jj_scanpos = xsp;
33689     xsp = jj_scanpos;
33690     if (jj_scan_token(118)) {
33691     jj_scanpos = xsp;
33692     if (jj_scan_token(143)) {
33693     jj_scanpos = xsp;
33694     if (jj_scan_token(183)) return true;
33695     }
33696     }
33697     return false;
33698   }
33699 
33700   private boolean jj_3_70() {
33701     if (jj_3R_145()) return true;
33702     return false;
33703   }
33704 
33705   private boolean jj_3R_405() {
33706     if (jj_scan_token(LOOP)) return true;
33707     Token xsp;
33708     if (jj_3R_444()) return true;
33709     while (true) {
33710       xsp = jj_scanpos;
33711       if (jj_3R_444()) { jj_scanpos = xsp; break; }
33712     }
33713     if (jj_scan_token(END)) return true;
33714     if (jj_scan_token(LOOP)) return true;
33715     xsp = jj_scanpos;
33716     if (jj_scan_token(417)) jj_scanpos = xsp;
33717     return false;
33718   }
33719 
33720   private boolean jj_3R_129() {
33721     if (jj_scan_token(SET)) return true;
33722     if (jj_scan_token(TRANSACTION)) return true;
33723     return false;
33724   }
33725 
33726   private boolean jj_3R_611() {
33727     if (jj_3R_172()) return true;
33728     return false;
33729   }
33730 
33731   private boolean jj_3R_585() {
33732     if (jj_scan_token(ELSIF)) return true;
33733     if (jj_3R_232()) return true;
33734     if (jj_scan_token(THEN)) return true;
33735     Token xsp;
33736     if (jj_3R_627()) return true;
33737     while (true) {
33738       xsp = jj_scanpos;
33739       if (jj_3R_627()) { jj_scanpos = xsp; break; }
33740     }
33741     return false;
33742   }
33743 
33744   private boolean jj_3_69() {
33745     Token xsp;
33746     xsp = jj_scanpos;
33747     if (jj_3R_147()) {
33748     jj_scanpos = xsp;
33749     if (jj_3R_148()) return true;
33750     }
33751     return false;
33752   }
33753 
33754   private boolean jj_3R_311() {
33755     if (jj_scan_token(REPLACE)) return true;
33756     return false;
33757   }
33758 
33759   private boolean jj_3R_480() {
33760     if (jj_scan_token(ELSE)) return true;
33761     Token xsp;
33762     if (jj_3R_611()) return true;
33763     while (true) {
33764       xsp = jj_scanpos;
33765       if (jj_3R_611()) { jj_scanpos = xsp; break; }
33766     }
33767     return false;
33768   }
33769 
33770   private boolean jj_3R_479() {
33771     if (jj_scan_token(WHEN)) return true;
33772     if (jj_3R_232()) return true;
33773     if (jj_scan_token(THEN)) return true;
33774     Token xsp;
33775     if (jj_3R_610()) return true;
33776     while (true) {
33777       xsp = jj_scanpos;
33778       if (jj_3R_610()) { jj_scanpos = xsp; break; }
33779     }
33780     return false;
33781   }
33782 
33783   private boolean jj_3R_439() {
33784     if (jj_3R_232()) return true;
33785     return false;
33786   }
33787 
33788   private boolean jj_3R_441() {
33789     if (jj_3R_480()) return true;
33790     return false;
33791   }
33792 
33793   private boolean jj_3R_440() {
33794     if (jj_3R_479()) return true;
33795     return false;
33796   }
33797 
33798   private boolean jj_3R_401() {
33799     if (jj_scan_token(CASE)) return true;
33800     Token xsp;
33801     xsp = jj_scanpos;
33802     if (jj_3R_439()) jj_scanpos = xsp;
33803     while (true) {
33804       xsp = jj_scanpos;
33805       if (jj_3R_440()) { jj_scanpos = xsp; break; }
33806     }
33807     xsp = jj_scanpos;
33808     if (jj_3R_441()) jj_scanpos = xsp;
33809     if (jj_scan_token(END)) return true;
33810     if (jj_scan_token(CASE)) return true;
33811     xsp = jj_scanpos;
33812     if (jj_scan_token(417)) jj_scanpos = xsp;
33813     return false;
33814   }
33815 
33816   private boolean jj_3R_354() {
33817     if (jj_3R_189()) return true;
33818     return false;
33819   }
33820 
33821   private boolean jj_3R_314() {
33822     Token xsp;
33823     if (jj_3R_354()) return true;
33824     while (true) {
33825       xsp = jj_scanpos;
33826       if (jj_3R_354()) { jj_scanpos = xsp; break; }
33827     }
33828     if (jj_3R_315()) return true;
33829     return false;
33830   }
33831 
33832   private boolean jj_3R_263() {
33833     if (jj_3R_315()) return true;
33834     return false;
33835   }
33836 
33837   private boolean jj_3R_262() {
33838     if (jj_3R_314()) return true;
33839     return false;
33840   }
33841 
33842   private boolean jj_3R_352() {
33843     if (jj_scan_token(DROP)) return true;
33844     return false;
33845   }
33846 
33847   private boolean jj_3R_172() {
33848     Token xsp;
33849     xsp = jj_scanpos;
33850     if (jj_3R_262()) {
33851     jj_scanpos = xsp;
33852     if (jj_3R_263()) return true;
33853     }
33854     return false;
33855   }
33856 
33857   private boolean jj_3R_373() {
33858     if (jj_3R_232()) return true;
33859     if (jj_scan_token(4)) return true;
33860     return false;
33861   }
33862 
33863   private boolean jj_3R_372() {
33864     if (jj_3R_416()) return true;
33865     return false;
33866   }
33867 
33868   private boolean jj_3R_371() {
33869     if (jj_3R_415()) return true;
33870     if (jj_scan_token(4)) return true;
33871     return false;
33872   }
33873 
33874   private boolean jj_3R_438() {
33875     if (jj_scan_token(LOCK)) return true;
33876     if (jj_scan_token(TABLE)) return true;
33877     return false;
33878   }
33879 
33880   private boolean jj_3R_370() {
33881     if (jj_3R_414()) return true;
33882     if (jj_scan_token(4)) return true;
33883     return false;
33884   }
33885 
33886   private boolean jj_3R_369() {
33887     if (jj_3R_270()) return true;
33888     if (jj_scan_token(4)) return true;
33889     return false;
33890   }
33891 
33892   private boolean jj_3R_368() {
33893     if (jj_3R_413()) return true;
33894     if (jj_scan_token(4)) return true;
33895     return false;
33896   }
33897 
33898   private boolean jj_3R_367() {
33899     if (jj_3R_412()) return true;
33900     if (jj_scan_token(4)) return true;
33901     return false;
33902   }
33903 
33904   private boolean jj_3R_366() {
33905     if (jj_3R_411()) return true;
33906     if (jj_scan_token(4)) return true;
33907     return false;
33908   }
33909 
33910   private boolean jj_3R_365() {
33911     if (jj_3R_410()) return true;
33912     if (jj_scan_token(4)) return true;
33913     return false;
33914   }
33915 
33916   private boolean jj_3R_364() {
33917     if (jj_3R_409()) return true;
33918     if (jj_scan_token(4)) return true;
33919     return false;
33920   }
33921 
33922   private boolean jj_3R_363() {
33923     if (jj_3R_408()) return true;
33924     if (jj_scan_token(4)) return true;
33925     return false;
33926   }
33927 
33928   private boolean jj_3R_362() {
33929     if (jj_3R_407()) return true;
33930     if (jj_scan_token(4)) return true;
33931     return false;
33932   }
33933 
33934   private boolean jj_3_42() {
33935     Token xsp;
33936     xsp = jj_scanpos;
33937     if (jj_3R_128()) {
33938     jj_scanpos = xsp;
33939     if (jj_scan_token(294)) {
33940     jj_scanpos = xsp;
33941     if (jj_scan_token(142)) {
33942     jj_scanpos = xsp;
33943     if (jj_scan_token(92)) {
33944     jj_scanpos = xsp;
33945     if (jj_scan_token(75)) {
33946     jj_scanpos = xsp;
33947     if (jj_scan_token(238)) {
33948     jj_scanpos = xsp;
33949     if (jj_scan_token(245)) {
33950     jj_scanpos = xsp;
33951     if (jj_scan_token(110)) {
33952     jj_scanpos = xsp;
33953     if (jj_3R_129()) {
33954     jj_scanpos = xsp;
33955     if (jj_3R_130()) {
33956     jj_scanpos = xsp;
33957     if (jj_scan_token(163)) {
33958     jj_scanpos = xsp;
33959     if (jj_scan_token(315)) return true;
33960     }
33961     }
33962     }
33963     }
33964     }
33965     }
33966     }
33967     }
33968     }
33969     }
33970     }
33971     return false;
33972   }
33973 
33974   private boolean jj_3R_128() {
33975     Token xsp;
33976     xsp = jj_scanpos;
33977     if (jj_scan_token(5)) jj_scanpos = xsp;
33978     if (jj_scan_token(SELECT)) return true;
33979     return false;
33980   }
33981 
33982   private boolean jj_3R_361() {
33983     if (jj_3R_406()) return true;
33984     if (jj_scan_token(4)) return true;
33985     return false;
33986   }
33987 
33988   private boolean jj_3R_360() {
33989     if (jj_3R_405()) return true;
33990     if (jj_scan_token(4)) return true;
33991     return false;
33992   }
33993 
33994   private boolean jj_3R_359() {
33995     if (jj_3R_404()) return true;
33996     if (jj_scan_token(4)) return true;
33997     return false;
33998   }
33999 
34000   private boolean jj_3R_358() {
34001     if (jj_3R_403()) return true;
34002     if (jj_scan_token(4)) return true;
34003     return false;
34004   }
34005 
34006   private boolean jj_3R_357() {
34007     if (jj_3R_402()) return true;
34008     if (jj_scan_token(4)) return true;
34009     return false;
34010   }
34011 
34012   private boolean jj_3R_356() {
34013     if (jj_3R_401()) return true;
34014     if (jj_scan_token(4)) return true;
34015     return false;
34016   }
34017 
34018   private boolean jj_3R_351() {
34019     Token xsp;
34020     xsp = jj_scanpos;
34021     if (jj_scan_token(6)) jj_scanpos = xsp;
34022     xsp = jj_scanpos;
34023     if (jj_scan_token(43)) {
34024     jj_scanpos = xsp;
34025     if (jj_scan_token(168)) return true;
34026     }
34027     return false;
34028   }
34029 
34030   private boolean jj_3R_310() {
34031     Token xsp;
34032     xsp = jj_scanpos;
34033     if (jj_3R_351()) {
34034     jj_scanpos = xsp;
34035     if (jj_3R_352()) return true;
34036     }
34037     return false;
34038   }
34039 
34040   private boolean jj_3_43() {
34041     if (jj_3R_131()) return true;
34042     if (jj_scan_token(4)) return true;
34043     return false;
34044   }
34045 
34046   private boolean jj_3R_355() {
34047     if (jj_3R_400()) return true;
34048     Token xsp;
34049     xsp = jj_scanpos;
34050     if (jj_scan_token(4)) jj_scanpos = xsp;
34051     return false;
34052   }
34053 
34054   private boolean jj_3R_437() {
34055     if (jj_scan_token(SET)) return true;
34056     if (jj_scan_token(TRANSACTION)) return true;
34057     return false;
34058   }
34059 
34060   private boolean jj_3R_315() {
34061     Token xsp;
34062     xsp = jj_scanpos;
34063     if (jj_3R_355()) {
34064     jj_scanpos = xsp;
34065     if (jj_3_43()) {
34066     jj_scanpos = xsp;
34067     if (jj_3R_356()) {
34068     jj_scanpos = xsp;
34069     if (jj_3R_357()) {
34070     jj_scanpos = xsp;
34071     if (jj_3R_358()) {
34072     jj_scanpos = xsp;
34073     if (jj_3R_359()) {
34074     jj_scanpos = xsp;
34075     if (jj_3R_360()) {
34076     jj_scanpos = xsp;
34077     if (jj_3R_361()) {
34078     jj_scanpos = xsp;
34079     if (jj_3R_362()) {
34080     jj_scanpos = xsp;
34081     if (jj_3R_363()) {
34082     jj_scanpos = xsp;
34083     if (jj_3R_364()) {
34084     jj_scanpos = xsp;
34085     if (jj_3R_365()) {
34086     jj_scanpos = xsp;
34087     if (jj_3R_366()) {
34088     jj_scanpos = xsp;
34089     if (jj_3R_367()) {
34090     jj_scanpos = xsp;
34091     if (jj_3R_368()) {
34092     jj_scanpos = xsp;
34093     if (jj_3R_369()) {
34094     jj_scanpos = xsp;
34095     if (jj_3R_370()) {
34096     jj_scanpos = xsp;
34097     if (jj_3R_371()) {
34098     jj_scanpos = xsp;
34099     if (jj_3R_372()) {
34100     jj_scanpos = xsp;
34101     if (jj_3R_373()) return true;
34102     }
34103     }
34104     }
34105     }
34106     }
34107     }
34108     }
34109     }
34110     }
34111     }
34112     }
34113     }
34114     }
34115     }
34116     }
34117     }
34118     }
34119     }
34120     }
34121     return false;
34122   }
34123 
34124   private boolean jj_3R_306() {
34125     if (jj_3R_146()) return true;
34126     return false;
34127   }
34128 
34129   private boolean jj_3R_258() {
34130     if (jj_scan_token(ALTER)) return true;
34131     if (jj_scan_token(TYPE)) return true;
34132     if (jj_3R_127()) return true;
34133     Token xsp;
34134     while (true) {
34135       xsp = jj_scanpos;
34136       if (jj_3R_310()) { jj_scanpos = xsp; break; }
34137     }
34138     xsp = jj_scanpos;
34139     if (jj_3R_311()) jj_scanpos = xsp;
34140     while (true) {
34141       xsp = jj_scanpos;
34142       if (jj_3R_312()) { jj_scanpos = xsp; break; }
34143     }
34144     xsp = jj_scanpos;
34145     if (jj_3R_313()) jj_scanpos = xsp;
34146     return false;
34147   }
34148 
34149   private boolean jj_3_68() {
34150     if (jj_3R_146()) return true;
34151     return false;
34152   }
34153 
34154   private boolean jj_3R_259() {
34155     if (jj_3R_258()) return true;
34156     return false;
34157   }
34158 
34159   private boolean jj_3R_166() {
34160     Token xsp;
34161     xsp = jj_scanpos;
34162     if (jj_scan_token(4)) {
34163     jj_scanpos = xsp;
34164     if (jj_scan_token(1)) return true;
34165     }
34166     while (true) {
34167       xsp = jj_scanpos;
34168       if (jj_3R_259()) { jj_scanpos = xsp; break; }
34169     }
34170     return false;
34171   }
34172 
34173   private boolean jj_3R_165() {
34174     if (jj_3R_258()) return true;
34175     return false;
34176   }
34177 
34178   private boolean jj_3R_308() {
34179     if (jj_3R_145()) return true;
34180     return false;
34181   }
34182 
34183   private boolean jj_3R_309() {
34184     if (jj_3R_349()) return true;
34185     return false;
34186   }
34187 
34188   private boolean jj_3R_247() {
34189     if (jj_scan_token(WRAPPED)) return true;
34190     return false;
34191   }
34192 
34193   private boolean jj_3R_164() {
34194     Token xsp;
34195     xsp = jj_scanpos;
34196     if (jj_scan_token(181)) jj_scanpos = xsp;
34197     xsp = jj_scanpos;
34198     if (jj_scan_token(118)) {
34199     jj_scanpos = xsp;
34200     if (jj_scan_token(143)) {
34201     jj_scanpos = xsp;
34202     if (jj_scan_token(183)) return true;
34203     }
34204     }
34205     return false;
34206   }
34207 
34208   private boolean jj_3R_257() {
34209     if (jj_scan_token(6)) return true;
34210     Token xsp;
34211     xsp = jj_scanpos;
34212     if (jj_3R_308()) {
34213     jj_scanpos = xsp;
34214     if (jj_3_68()) {
34215     jj_scanpos = xsp;
34216     if (jj_3R_309()) return true;
34217     }
34218     }
34219     return false;
34220   }
34221 
34222   private boolean jj_3R_307() {
34223     if (jj_3R_349()) return true;
34224     return false;
34225   }
34226 
34227   private boolean jj_3_67() {
34228     if (jj_3R_145()) return true;
34229     return false;
34230   }
34231 
34232   private boolean jj_3R_256() {
34233     Token xsp;
34234     xsp = jj_scanpos;
34235     if (jj_3_67()) {
34236     jj_scanpos = xsp;
34237     if (jj_3R_306()) {
34238     jj_scanpos = xsp;
34239     if (jj_3R_307()) return true;
34240     }
34241     }
34242     return false;
34243   }
34244 
34245   private boolean jj_3R_163() {
34246     if (jj_scan_token(5)) return true;
34247     Token xsp;
34248     while (true) {
34249       xsp = jj_scanpos;
34250       if (jj_3R_256()) { jj_scanpos = xsp; break; }
34251     }
34252     while (true) {
34253       xsp = jj_scanpos;
34254       if (jj_3R_257()) { jj_scanpos = xsp; break; }
34255     }
34256     if (jj_scan_token(7)) return true;
34257     return false;
34258   }
34259 
34260   private boolean jj_3R_599() {
34261     if (jj_3R_123()) return true;
34262     return false;
34263   }
34264 
34265   private boolean jj_3R_162() {
34266     if (jj_3R_247()) return true;
34267     return false;
34268   }
34269 
34270   private boolean jj_3_65() {
34271     Token xsp;
34272     xsp = jj_scanpos;
34273     if (jj_scan_token(150)) {
34274     jj_scanpos = xsp;
34275     if (jj_scan_token(50)) return true;
34276     }
34277     if (jj_3R_144()) return true;
34278     if (jj_scan_token(OF)) return true;
34279     if (jj_3R_234()) return true;
34280     return false;
34281   }
34282 
34283   private boolean jj_3R_143() {
34284     if (jj_3R_237()) return true;
34285     return false;
34286   }
34287 
34288   private boolean jj_3_64() {
34289     Token xsp;
34290     xsp = jj_scanpos;
34291     if (jj_scan_token(150)) {
34292     jj_scanpos = xsp;
34293     if (jj_scan_token(50)) return true;
34294     }
34295     if (jj_scan_token(OPAQUE)) return true;
34296     if (jj_scan_token(VARYING)) return true;
34297     if (jj_scan_token(24)) return true;
34298     return false;
34299   }
34300 
34301   private boolean jj_3_66() {
34302     if (jj_scan_token(EXTERNAL)) return true;
34303     if (jj_scan_token(IDENTIFIER)) return true;
34304     if (jj_scan_token(IDENTIFIER)) return true;
34305     if (jj_scan_token(LANGUAGE)) return true;
34306     if (jj_scan_token(JAVA)) return true;
34307     if (jj_scan_token(USING)) return true;
34308     if (jj_scan_token(IDENTIFIER)) return true;
34309     return false;
34310   }
34311 
34312   private boolean jj_3_63() {
34313     Token xsp;
34314     xsp = jj_scanpos;
34315     if (jj_scan_token(150)) {
34316     jj_scanpos = xsp;
34317     if (jj_scan_token(50)) return true;
34318     }
34319     if (jj_scan_token(OBJECT)) return true;
34320     return false;
34321   }
34322 
34323   private boolean jj_3R_142() {
34324     if (jj_scan_token(AUTHID)) return true;
34325     Token xsp;
34326     xsp = jj_scanpos;
34327     if (jj_scan_token(37)) {
34328     jj_scanpos = xsp;
34329     if (jj_scan_token(36)) return true;
34330     }
34331     return false;
34332   }
34333 
34334   private boolean jj_3R_255() {
34335     if (jj_scan_token(UNDER)) return true;
34336     if (jj_3R_153()) return true;
34337     return false;
34338   }
34339 
34340   private boolean jj_3R_161() {
34341     Token xsp;
34342     xsp = jj_scanpos;
34343     if (jj_3R_255()) {
34344     jj_scanpos = xsp;
34345     if (jj_3_63()) {
34346     jj_scanpos = xsp;
34347     if (jj_3_64()) {
34348     jj_scanpos = xsp;
34349     if (jj_3_65()) return true;
34350     }
34351     }
34352     }
34353     return false;
34354   }
34355 
34356   private boolean jj_3R_254() {
34357     Token xsp;
34358     xsp = jj_scanpos;
34359     if (jj_scan_token(99)) {
34360     jj_scanpos = xsp;
34361     if (jj_scan_token(180)) return true;
34362     }
34363     return false;
34364   }
34365 
34366   private boolean jj_3R_598() {
34367     if (jj_3R_348()) return true;
34368     return false;
34369   }
34370 
34371   private boolean jj_3_62() {
34372     Token xsp;
34373     xsp = jj_scanpos;
34374     if (jj_3R_142()) {
34375     jj_scanpos = xsp;
34376     if (jj_3R_143()) return true;
34377     }
34378     return false;
34379   }
34380 
34381   private boolean jj_3R_400() {
34382     Token xsp;
34383     xsp = jj_scanpos;
34384     if (jj_scan_token(247)) {
34385     jj_scanpos = xsp;
34386     if (jj_scan_token(294)) {
34387     jj_scanpos = xsp;
34388     if (jj_scan_token(142)) {
34389     jj_scanpos = xsp;
34390     if (jj_scan_token(92)) {
34391     jj_scanpos = xsp;
34392     if (jj_scan_token(75)) {
34393     jj_scanpos = xsp;
34394     if (jj_scan_token(238)) {
34395     jj_scanpos = xsp;
34396     if (jj_scan_token(245)) {
34397     jj_scanpos = xsp;
34398     if (jj_scan_token(110)) {
34399     jj_scanpos = xsp;
34400     if (jj_3R_437()) {
34401     jj_scanpos = xsp;
34402     if (jj_3R_438()) {
34403     jj_scanpos = xsp;
34404     if (jj_scan_token(163)) {
34405     jj_scanpos = xsp;
34406     if (jj_scan_token(315)) return true;
34407     }
34408     }
34409     }
34410     }
34411     }
34412     }
34413     }
34414     }
34415     }
34416     }
34417     }
34418     if (jj_3R_178()) return true;
34419     return false;
34420   }
34421 
34422   private boolean jj_3_61() {
34423     if (jj_scan_token(OID)) return true;
34424     if (jj_scan_token(STRING_LITERAL)) return true;
34425     return false;
34426   }
34427 
34428   private boolean jj_3R_485() {
34429     return false;
34430   }
34431 
34432   private boolean jj_3R_253() {
34433     if (jj_scan_token(OR)) return true;
34434     if (jj_scan_token(REPLACE)) return true;
34435     return false;
34436   }
34437 
34438   private boolean jj_3R_597() {
34439     if (jj_3R_172()) return true;
34440     return false;
34441   }
34442 
34443   private boolean jj_3R_160() {
34444     if (jj_scan_token(CREATE)) return true;
34445     Token xsp;
34446     xsp = jj_scanpos;
34447     if (jj_3R_253()) jj_scanpos = xsp;
34448     xsp = jj_scanpos;
34449     if (jj_3R_254()) jj_scanpos = xsp;
34450     return false;
34451   }
34452 
34453   private boolean jj_3R_104() {
34454     Token xsp;
34455     xsp = jj_scanpos;
34456     if (jj_3R_160()) jj_scanpos = xsp;
34457     if (jj_scan_token(TYPE)) return true;
34458     if (jj_3R_153()) return true;
34459     xsp = jj_scanpos;
34460     if (jj_scan_token(122)) jj_scanpos = xsp;
34461     xsp = jj_scanpos;
34462     if (jj_3_61()) jj_scanpos = xsp;
34463     while (true) {
34464       xsp = jj_scanpos;
34465       if (jj_3_62()) { jj_scanpos = xsp; break; }
34466     }
34467     xsp = jj_scanpos;
34468     if (jj_3R_161()) jj_scanpos = xsp;
34469     xsp = jj_scanpos;
34470     if (jj_3_66()) jj_scanpos = xsp;
34471     xsp = jj_scanpos;
34472     if (jj_3R_162()) jj_scanpos = xsp;
34473     xsp = jj_scanpos;
34474     if (jj_3R_163()) jj_scanpos = xsp;
34475     while (true) {
34476       xsp = jj_scanpos;
34477       if (jj_3R_164()) { jj_scanpos = xsp; break; }
34478     }
34479     while (true) {
34480       xsp = jj_scanpos;
34481       if (jj_3R_165()) { jj_scanpos = xsp; break; }
34482     }
34483     xsp = jj_scanpos;
34484     if (jj_3R_166()) jj_scanpos = xsp;
34485     return false;
34486   }
34487 
34488   private boolean jj_3R_562() {
34489     if (jj_3R_190()) return true;
34490     if (jj_scan_token(BEGIN)) return true;
34491     Token xsp;
34492     while (true) {
34493       xsp = jj_scanpos;
34494       if (jj_3R_597()) { jj_scanpos = xsp; break; }
34495     }
34496     xsp = jj_scanpos;
34497     if (jj_3R_598()) jj_scanpos = xsp;
34498     if (jj_scan_token(END)) return true;
34499     xsp = jj_scanpos;
34500     if (jj_3R_599()) jj_scanpos = xsp;
34501     if (jj_scan_token(4)) return true;
34502     return false;
34503   }
34504 
34505   private boolean jj_3R_561() {
34506     if (jj_3R_122()) return true;
34507     Token xsp;
34508     xsp = jj_scanpos;
34509     if (jj_scan_token(4)) jj_scanpos = xsp;
34510     return false;
34511   }
34512 
34513   private boolean jj_3R_525() {
34514     Token xsp;
34515     xsp = jj_scanpos;
34516     if (jj_scan_token(150)) {
34517     jj_scanpos = xsp;
34518     if (jj_scan_token(50)) return true;
34519     }
34520     xsp = jj_scanpos;
34521     if (jj_3R_561()) {
34522     jj_scanpos = xsp;
34523     if (jj_3R_562()) return true;
34524     }
34525     return false;
34526   }
34527 
34528   private boolean jj_3R_186() {
34529     return false;
34530   }
34531 
34532   private boolean jj_3_59() {
34533     if (jj_3R_123()) return true;
34534     if (jj_scan_token(3)) return true;
34535     return false;
34536   }
34537 
34538   private boolean jj_3R_188() {
34539     return false;
34540   }
34541 
34542   private boolean jj_3R_240() {
34543     Token xsp;
34544     xsp = jj_scanpos;
34545     if (jj_scan_token(160)) {
34546     jj_scanpos = xsp;
34547     if (jj_scan_token(201)) return true;
34548     }
34549     return false;
34550   }
34551 
34552   private boolean jj_3R_239() {
34553     Token xsp;
34554     xsp = jj_scanpos;
34555     if (jj_scan_token(181)) jj_scanpos = xsp;
34556     xsp = jj_scanpos;
34557     if (jj_scan_token(205)) {
34558     jj_scanpos = xsp;
34559     if (jj_scan_token(143)) {
34560     jj_scanpos = xsp;
34561     if (jj_scan_token(118)) return true;
34562     }
34563     }
34564     return false;
34565   }
34566 
34567   private boolean jj_3_60() {
34568     if (jj_3R_123()) return true;
34569     if (jj_scan_token(3)) return true;
34570     if (jj_3R_123()) return true;
34571     if (jj_scan_token(3)) return true;
34572     if (jj_3R_123()) return true;
34573     return false;
34574   }
34575 
34576   private boolean jj_3R_145() {
34577     Token xsp;
34578     while (true) {
34579       xsp = jj_scanpos;
34580       if (jj_3R_239()) { jj_scanpos = xsp; break; }
34581     }
34582     xsp = jj_scanpos;
34583     if (jj_3R_240()) jj_scanpos = xsp;
34584     xsp = jj_scanpos;
34585     if (jj_scan_token(79)) {
34586     jj_scanpos = xsp;
34587     if (jj_scan_token(162)) {
34588     jj_scanpos = xsp;
34589     if (jj_scan_token(259)) return true;
34590     }
34591     }
34592     if (jj_3R_192()) return true;
34593     xsp = jj_scanpos;
34594     if (jj_scan_token(94)) jj_scanpos = xsp;
34595     xsp = jj_scanpos;
34596     if (jj_scan_token(207)) jj_scanpos = xsp;
34597     xsp = jj_scanpos;
34598     if (jj_scan_token(211)) jj_scanpos = xsp;
34599     xsp = jj_scanpos;
34600     if (jj_scan_token(233)) jj_scanpos = xsp;
34601     xsp = jj_scanpos;
34602     if (jj_3R_525()) jj_scanpos = xsp;
34603     return false;
34604   }
34605 
34606   private boolean jj_3R_454() {
34607     if (jj_3R_172()) return true;
34608     return false;
34609   }
34610 
34611   private boolean jj_3R_260() {
34612     if (jj_3R_123()) return true;
34613     return false;
34614   }
34615 
34616   private boolean jj_3R_558() {
34617     return false;
34618   }
34619 
34620   private boolean jj_3R_183() {
34621     if (jj_3R_141()) return true;
34622     if (jj_scan_token(IDENTIFIED)) return true;
34623     return false;
34624   }
34625 
34626   private boolean jj_3R_453() {
34627     if (jj_scan_token(OR)) return true;
34628     if (jj_3R_127()) return true;
34629     return false;
34630   }
34631 
34632   private boolean jj_3R_455() {
34633     if (jj_3R_172()) return true;
34634     return false;
34635   }
34636 
34637   private boolean jj_3R_182() {
34638     if (jj_scan_token(CONNECT)) return true;
34639     if (jj_scan_token(TO)) return true;
34640     return false;
34641   }
34642 
34643   private boolean jj_3R_111() {
34644     if (jj_scan_token(CREATE)) return true;
34645     Token xsp;
34646     xsp = jj_scanpos;
34647     if (jj_scan_token(407)) jj_scanpos = xsp;
34648     xsp = jj_scanpos;
34649     if (jj_scan_token(221)) jj_scanpos = xsp;
34650     if (jj_scan_token(DATABASE)) return true;
34651     if (jj_scan_token(LINK)) return true;
34652     if (jj_3R_153()) return true;
34653     xsp = jj_scanpos;
34654     if (jj_3R_182()) {
34655     jj_scanpos = xsp;
34656     if (jj_3R_183()) return true;
34657     }
34658     return false;
34659   }
34660 
34661   private boolean jj_3R_180() {
34662     if (jj_scan_token(OR)) return true;
34663     if (jj_scan_token(REPLACE)) return true;
34664     return false;
34665   }
34666 
34667   private boolean jj_3R_178() {
34668     return false;
34669   }
34670 
34671   private boolean jj_3R_110() {
34672     if (jj_scan_token(CREATE)) return true;
34673     Token xsp;
34674     xsp = jj_scanpos;
34675     if (jj_3R_180()) jj_scanpos = xsp;
34676     if (jj_scan_token(DIRECTORY)) return true;
34677     if (jj_3R_153()) return true;
34678     if (jj_scan_token(AS)) return true;
34679     if (jj_3R_181()) return true;
34680     xsp = jj_scanpos;
34681     if (jj_scan_token(4)) {
34682     jj_scanpos = xsp;
34683     if (jj_scan_token(1)) return true;
34684     }
34685     return false;
34686   }
34687 
34688   private boolean jj_3R_417() {
34689     if (jj_scan_token(WHEN)) return true;
34690     if (jj_scan_token(OTHERS)) return true;
34691     if (jj_scan_token(THEN)) return true;
34692     Token xsp;
34693     if (jj_3R_455()) return true;
34694     while (true) {
34695       xsp = jj_scanpos;
34696       if (jj_3R_455()) { jj_scanpos = xsp; break; }
34697     }
34698     return false;
34699   }
34700 
34701   private boolean jj_3_41() {
34702     if (jj_scan_token(WHEN)) return true;
34703     if (jj_3R_127()) return true;
34704     Token xsp;
34705     while (true) {
34706       xsp = jj_scanpos;
34707       if (jj_3R_453()) { jj_scanpos = xsp; break; }
34708     }
34709     if (jj_scan_token(THEN)) return true;
34710     if (jj_3R_454()) return true;
34711     while (true) {
34712       xsp = jj_scanpos;
34713       if (jj_3R_454()) { jj_scanpos = xsp; break; }
34714     }
34715     return false;
34716   }
34717 
34718   private boolean jj_3R_179() {
34719     if (jj_scan_token(OR)) return true;
34720     if (jj_scan_token(REPLACE)) return true;
34721     return false;
34722   }
34723 
34724   private boolean jj_3R_261() {
34725     if (jj_scan_token(6)) return true;
34726     return false;
34727   }
34728 
34729   private boolean jj_3R_109() {
34730     if (jj_scan_token(CREATE)) return true;
34731     Token xsp;
34732     xsp = jj_scanpos;
34733     if (jj_3R_179()) jj_scanpos = xsp;
34734     xsp = jj_scanpos;
34735     if (jj_scan_token(221)) jj_scanpos = xsp;
34736     if (jj_scan_token(SYNONYM)) return true;
34737     if (jj_3R_153()) return true;
34738     if (jj_scan_token(FOR)) return true;
34739     if (jj_3R_153()) return true;
34740     xsp = jj_scanpos;
34741     if (jj_scan_token(4)) {
34742     jj_scanpos = xsp;
34743     if (jj_scan_token(1)) return true;
34744     }
34745     return false;
34746   }
34747 
34748   private boolean jj_3R_348() {
34749     if (jj_scan_token(EXCEPTION)) return true;
34750     Token xsp;
34751     while (true) {
34752       xsp = jj_scanpos;
34753       if (jj_3_41()) { jj_scanpos = xsp; break; }
34754     }
34755     xsp = jj_scanpos;
34756     if (jj_3R_417()) jj_scanpos = xsp;
34757     return false;
34758   }
34759 
34760   private boolean jj_3R_169() {
34761     if (jj_scan_token(OR)) return true;
34762     if (jj_scan_token(REPLACE)) return true;
34763     return false;
34764   }
34765 
34766   private boolean jj_3_40() {
34767     if (jj_scan_token(5)) return true;
34768     if (jj_3R_126()) return true;
34769     if (jj_scan_token(7)) return true;
34770     return false;
34771   }
34772 
34773   private boolean jj_3R_171() {
34774     if (jj_scan_token(5)) return true;
34775     if (jj_3R_260()) return true;
34776     Token xsp;
34777     while (true) {
34778       xsp = jj_scanpos;
34779       if (jj_3R_261()) { jj_scanpos = xsp; break; }
34780     }
34781     if (jj_scan_token(7)) return true;
34782     return false;
34783   }
34784 
34785   private boolean jj_3R_170() {
34786     Token xsp;
34787     xsp = jj_scanpos;
34788     if (jj_scan_token(177)) jj_scanpos = xsp;
34789     if (jj_scan_token(FORCE)) return true;
34790     return false;
34791   }
34792 
34793   private boolean jj_3R_106() {
34794     if (jj_scan_token(CREATE)) return true;
34795     Token xsp;
34796     xsp = jj_scanpos;
34797     if (jj_3R_169()) jj_scanpos = xsp;
34798     xsp = jj_scanpos;
34799     if (jj_3R_170()) jj_scanpos = xsp;
34800     if (jj_scan_token(VIEW)) return true;
34801     if (jj_3R_153()) return true;
34802     xsp = jj_scanpos;
34803     if (jj_3R_171()) jj_scanpos = xsp;
34804     if (jj_scan_token(AS)) return true;
34805     if (jj_3R_172()) return true;
34806     xsp = jj_scanpos;
34807     if (jj_scan_token(4)) {
34808     jj_scanpos = xsp;
34809     if (jj_scan_token(1)) return true;
34810     }
34811     return false;
34812   }
34813 
34814   private boolean jj_3R_475() {
34815     if (jj_scan_token(TO)) return true;
34816     Token xsp;
34817     xsp = jj_scanpos;
34818     if (jj_scan_token(313)) {
34819     jj_scanpos = xsp;
34820     if (jj_scan_token(171)) {
34821     jj_scanpos = xsp;
34822     if (jj_scan_token(88)) {
34823     jj_scanpos = xsp;
34824     if (jj_scan_token(132)) {
34825     jj_scanpos = xsp;
34826     if (jj_scan_token(166)) {
34827     jj_scanpos = xsp;
34828     if (jj_scan_token(246)) return true;
34829     }
34830     }
34831     }
34832     }
34833     }
34834     xsp = jj_scanpos;
34835     if (jj_3_40()) jj_scanpos = xsp;
34836     return false;
34837   }
34838 
34839   private boolean jj_3R_501() {
34840     if (jj_scan_token(LOCAL)) return true;
34841     return false;
34842   }
34843 
34844   private boolean jj_3R_168() {
34845     if (jj_3R_123()) return true;
34846     if (jj_3R_234()) return true;
34847     return false;
34848   }
34849 
34850   private boolean jj_3R_620() {
34851     if (jj_scan_token(6)) return true;
34852     if (jj_3R_123()) return true;
34853     return false;
34854   }
34855 
34856   private boolean jj_3R_474() {
34857     if (jj_scan_token(WITH)) return true;
34858     Token xsp;
34859     xsp = jj_scanpos;
34860     if (jj_3R_501()) jj_scanpos = xsp;
34861     if (jj_scan_token(TIME)) return true;
34862     if (jj_scan_token(ZONE)) return true;
34863     return false;
34864   }
34865 
34866   private boolean jj_3R_430() {
34867     Token xsp;
34868     xsp = jj_scanpos;
34869     if (jj_3R_474()) {
34870     jj_scanpos = xsp;
34871     if (jj_3R_475()) return true;
34872     }
34873     return false;
34874   }
34875 
34876   private boolean jj_3R_619() {
34877     if (jj_scan_token(6)) return true;
34878     if (jj_3R_123()) return true;
34879     return false;
34880   }
34881 
34882   private boolean jj_3_39() {
34883     if (jj_scan_token(5)) return true;
34884     if (jj_3R_126()) return true;
34885     if (jj_scan_token(7)) return true;
34886     return false;
34887   }
34888 
34889   private boolean jj_3R_167() {
34890     if (jj_scan_token(GLOBAL)) return true;
34891     if (jj_scan_token(TEMPORARY)) return true;
34892     return false;
34893   }
34894 
34895   private boolean jj_3_58() {
34896     if (jj_scan_token(ON)) return true;
34897     if (jj_scan_token(COMMIT)) return true;
34898     return false;
34899   }
34900 
34901   private boolean jj_3R_105() {
34902     if (jj_scan_token(CREATE)) return true;
34903     Token xsp;
34904     xsp = jj_scanpos;
34905     if (jj_3R_167()) jj_scanpos = xsp;
34906     if (jj_scan_token(TABLE)) return true;
34907     if (jj_3R_153()) return true;
34908     if (jj_scan_token(5)) return true;
34909     if (jj_3R_168()) return true;
34910     return false;
34911   }
34912 
34913   private boolean jj_3R_429() {
34914     Token xsp;
34915     xsp = jj_scanpos;
34916     if (jj_scan_token(313)) {
34917     jj_scanpos = xsp;
34918     if (jj_scan_token(171)) {
34919     jj_scanpos = xsp;
34920     if (jj_scan_token(88)) {
34921     jj_scanpos = xsp;
34922     if (jj_scan_token(132)) {
34923     jj_scanpos = xsp;
34924     if (jj_scan_token(166)) {
34925     jj_scanpos = xsp;
34926     if (jj_scan_token(246)) return true;
34927     }
34928     }
34929     }
34930     }
34931     }
34932     return false;
34933   }
34934 
34935   private boolean jj_3R_428() {
34936     if (jj_3R_181()) return true;
34937     return false;
34938   }
34939 
34940   private boolean jj_3R_484() {
34941     if (jj_scan_token(6)) return true;
34942     if (jj_3R_126()) return true;
34943     return false;
34944   }
34945 
34946   private boolean jj_3R_427() {
34947     if (jj_scan_token(CHARACTER_LITERAL)) return true;
34948     return false;
34949   }
34950 
34951   private boolean jj_3R_614() {
34952     Token xsp;
34953     xsp = jj_scanpos;
34954     if (jj_scan_token(124)) {
34955     jj_scanpos = xsp;
34956     if (jj_scan_token(220)) {
34957     jj_scanpos = xsp;
34958     if (jj_scan_token(206)) {
34959     jj_scanpos = xsp;
34960     if (jj_scan_token(279)) {
34961     jj_scanpos = xsp;
34962     if (jj_scan_token(281)) return true;
34963     }
34964     }
34965     }
34966     }
34967     return false;
34968   }
34969 
34970   private boolean jj_3R_483() {
34971     Token xsp;
34972     xsp = jj_scanpos;
34973     if (jj_scan_token(16)) {
34974     jj_scanpos = xsp;
34975     if (jj_scan_token(17)) return true;
34976     }
34977     return false;
34978   }
34979 
34980   private boolean jj_3R_347() {
34981     Token xsp;
34982     xsp = jj_scanpos;
34983     if (jj_scan_token(124)) {
34984     jj_scanpos = xsp;
34985     if (jj_scan_token(220)) {
34986     jj_scanpos = xsp;
34987     if (jj_scan_token(206)) {
34988     jj_scanpos = xsp;
34989     if (jj_scan_token(279)) {
34990     jj_scanpos = xsp;
34991     if (jj_scan_token(281)) return true;
34992     }
34993     }
34994     }
34995     }
34996     return false;
34997   }
34998 
34999   private boolean jj_3R_594() {
35000     if (jj_scan_token(6)) return true;
35001     Token xsp;
35002     xsp = jj_scanpos;
35003     if (jj_3R_614()) jj_scanpos = xsp;
35004     if (jj_3R_127()) return true;
35005     return false;
35006   }
35007 
35008   private boolean jj_3R_237() {
35009     if (jj_scan_token(ACCESSIBLE)) return true;
35010     if (jj_scan_token(BY)) return true;
35011     if (jj_scan_token(5)) return true;
35012     Token xsp;
35013     xsp = jj_scanpos;
35014     if (jj_3R_347()) jj_scanpos = xsp;
35015     if (jj_3R_127()) return true;
35016     while (true) {
35017       xsp = jj_scanpos;
35018       if (jj_3R_594()) { jj_scanpos = xsp; break; }
35019     }
35020     if (jj_scan_token(7)) return true;
35021     return false;
35022   }
35023 
35024   private boolean jj_3R_615() {
35025     Token xsp;
35026     xsp = jj_scanpos;
35027     if (jj_scan_token(129)) {
35028     jj_scanpos = xsp;
35029     if (jj_scan_token(223)) return true;
35030     }
35031     if (jj_scan_token(5)) return true;
35032     if (jj_3R_123()) return true;
35033     while (true) {
35034       xsp = jj_scanpos;
35035       if (jj_3R_619()) { jj_scanpos = xsp; break; }
35036     }
35037     if (jj_scan_token(7)) return true;
35038     return false;
35039   }
35040 
35041   private boolean jj_3R_616() {
35042     Token xsp;
35043     xsp = jj_scanpos;
35044     if (jj_scan_token(201)) {
35045     jj_scanpos = xsp;
35046     if (jj_scan_token(70)) return true;
35047     }
35048     if (jj_scan_token(BY)) return true;
35049     if (jj_scan_token(5)) return true;
35050     if (jj_3R_123()) return true;
35051     while (true) {
35052       xsp = jj_scanpos;
35053       if (jj_3R_620()) { jj_scanpos = xsp; break; }
35054     }
35055     if (jj_scan_token(7)) return true;
35056     return false;
35057   }
35058 
35059   private boolean jj_3_34() {
35060     if (jj_scan_token(5)) return true;
35061     if (jj_3R_126()) return true;
35062     if (jj_scan_token(7)) return true;
35063     return false;
35064   }
35065 
35066   private boolean jj_3R_389() {
35067     Token xsp;
35068     xsp = jj_scanpos;
35069     if (jj_scan_token(147)) {
35070     jj_scanpos = xsp;
35071     if (jj_scan_token(272)) {
35072     jj_scanpos = xsp;
35073     if (jj_scan_token(87)) return true;
35074     }
35075     }
35076     xsp = jj_scanpos;
35077     if (jj_3R_427()) {
35078     jj_scanpos = xsp;
35079     if (jj_3R_428()) return true;
35080     }
35081     xsp = jj_scanpos;
35082     if (jj_3R_429()) jj_scanpos = xsp;
35083     xsp = jj_scanpos;
35084     if (jj_3_39()) jj_scanpos = xsp;
35085     xsp = jj_scanpos;
35086     if (jj_3R_430()) jj_scanpos = xsp;
35087     return false;
35088   }
35089 
35090   private boolean jj_3R_513() {
35091     if (jj_3R_181()) return true;
35092     return false;
35093   }
35094 
35095   private boolean jj_3R_424() {
35096     if (jj_scan_token(5)) return true;
35097     if (jj_scan_token(PARTITION)) return true;
35098     if (jj_3R_123()) return true;
35099     if (jj_scan_token(BY)) return true;
35100     Token xsp;
35101     xsp = jj_scanpos;
35102     if (jj_scan_token(48)) {
35103     jj_scanpos = xsp;
35104     if (jj_3R_615()) return true;
35105     }
35106     if (jj_scan_token(7)) return true;
35107     xsp = jj_scanpos;
35108     if (jj_3R_616()) jj_scanpos = xsp;
35109     return false;
35110   }
35111 
35112   private boolean jj_3R_118() {
35113     if (jj_3R_123()) return true;
35114     if (jj_scan_token(EXCEPTION)) return true;
35115     if (jj_scan_token(4)) return true;
35116     return false;
35117   }
35118 
35119   private boolean jj_3R_512() {
35120     if (jj_3R_123()) return true;
35121     return false;
35122   }
35123 
35124   private boolean jj_3R_463() {
35125     if (jj_3R_127()) return true;
35126     if (jj_scan_token(5)) return true;
35127     if (jj_3R_485()) return true;
35128     return false;
35129   }
35130 
35131   private boolean jj_3R_462() {
35132     if (jj_scan_token(INTERFACE)) return true;
35133     if (jj_scan_token(5)) return true;
35134     if (jj_scan_token(IDENTIFIER)) return true;
35135     if (jj_scan_token(6)) return true;
35136     if (jj_3R_123()) return true;
35137     Token xsp;
35138     xsp = jj_scanpos;
35139     if (jj_3R_484()) jj_scanpos = xsp;
35140     if (jj_scan_token(7)) return true;
35141     return false;
35142   }
35143 
35144   private boolean jj_3R_461() {
35145     if (jj_scan_token(EXCEPTION_INIT)) return true;
35146     if (jj_scan_token(5)) return true;
35147     if (jj_scan_token(IDENTIFIER)) return true;
35148     if (jj_scan_token(6)) return true;
35149     Token xsp;
35150     xsp = jj_scanpos;
35151     if (jj_3R_483()) jj_scanpos = xsp;
35152     if (jj_3R_126()) return true;
35153     if (jj_scan_token(7)) return true;
35154     return false;
35155   }
35156 
35157   private boolean jj_3R_482() {
35158     if (jj_scan_token(6)) return true;
35159     Token xsp;
35160     xsp = jj_scanpos;
35161     if (jj_3R_512()) {
35162     jj_scanpos = xsp;
35163     if (jj_3R_513()) return true;
35164     }
35165     return false;
35166   }
35167 
35168   private boolean jj_3R_460() {
35169     if (jj_scan_token(RESTRICT_REFERENCES)) return true;
35170     if (jj_scan_token(5)) return true;
35171     if (jj_3R_123()) return true;
35172     Token xsp;
35173     if (jj_3R_482()) return true;
35174     while (true) {
35175       xsp = jj_scanpos;
35176       if (jj_3R_482()) { jj_scanpos = xsp; break; }
35177     }
35178     if (jj_scan_token(7)) return true;
35179     return false;
35180   }
35181 
35182   private boolean jj_3R_459() {
35183     if (jj_scan_token(TIMESTAMP)) return true;
35184     if (jj_scan_token(5)) return true;
35185     if (jj_3R_181()) return true;
35186     if (jj_scan_token(7)) return true;
35187     return false;
35188   }
35189 
35190   private boolean jj_3_38() {
35191     if (jj_scan_token(TO)) return true;
35192     if (jj_scan_token(SECOND)) return true;
35193     Token xsp;
35194     xsp = jj_scanpos;
35195     if (jj_3_34()) jj_scanpos = xsp;
35196     return false;
35197   }
35198 
35199   private boolean jj_3_37() {
35200     if (jj_scan_token(TO)) return true;
35201     if (jj_scan_token(MONTH)) return true;
35202     return false;
35203   }
35204 
35205   private boolean jj_3_36() {
35206     if (jj_scan_token(WITH)) return true;
35207     if (jj_scan_token(TIME)) return true;
35208     if (jj_scan_token(ZONE)) return true;
35209     return false;
35210   }
35211 
35212   private boolean jj_3_35() {
35213     if (jj_scan_token(WITH)) return true;
35214     if (jj_scan_token(LOCAL)) return true;
35215     if (jj_scan_token(TIME)) return true;
35216     if (jj_scan_token(ZONE)) return true;
35217     return false;
35218   }
35219 
35220   private boolean jj_3R_205() {
35221     Token xsp;
35222     xsp = jj_scanpos;
35223     if (jj_3R_289()) {
35224     jj_scanpos = xsp;
35225     if (jj_3_35()) {
35226     jj_scanpos = xsp;
35227     if (jj_3_36()) {
35228     jj_scanpos = xsp;
35229     if (jj_3_37()) {
35230     jj_scanpos = xsp;
35231     if (jj_3_38()) return true;
35232     }
35233     }
35234     }
35235     }
35236     return false;
35237   }
35238 
35239   private boolean jj_3R_289() {
35240     if (jj_scan_token(CHARACTER)) return true;
35241     if (jj_scan_token(SET)) return true;
35242     if (jj_3R_293()) return true;
35243     return false;
35244   }
35245 
35246   private boolean jj_3R_418() {
35247     if (jj_scan_token(PRAGMA)) return true;
35248     Token xsp;
35249     xsp = jj_scanpos;
35250     if (jj_scan_token(38)) {
35251     jj_scanpos = xsp;
35252     if (jj_scan_token(41)) {
35253     jj_scanpos = xsp;
35254     if (jj_3R_459()) {
35255     jj_scanpos = xsp;
35256     if (jj_3R_460()) {
35257     jj_scanpos = xsp;
35258     if (jj_3R_461()) {
35259     jj_scanpos = xsp;
35260     if (jj_3R_462()) {
35261     jj_scanpos = xsp;
35262     if (jj_3R_463()) return true;
35263     }
35264     }
35265     }
35266     }
35267     }
35268     }
35269     if (jj_scan_token(4)) return true;
35270     return false;
35271   }
35272 
35273   private boolean jj_3R_436() {
35274     if (jj_scan_token(BYTE)) return true;
35275     return false;
35276   }
35277 
35278   private boolean jj_3R_435() {
35279     if (jj_scan_token(CHAR)) return true;
35280     return false;
35281   }
35282 
35283   private boolean jj_3R_434() {
35284     if (jj_scan_token(6)) return true;
35285     if (jj_3R_478()) return true;
35286     return false;
35287   }
35288 
35289   private boolean jj_3_33() {
35290     if (jj_scan_token(5)) return true;
35291     if (jj_3R_126()) return true;
35292     Token xsp;
35293     xsp = jj_scanpos;
35294     if (jj_3R_434()) jj_scanpos = xsp;
35295     xsp = jj_scanpos;
35296     if (jj_3R_435()) jj_scanpos = xsp;
35297     xsp = jj_scanpos;
35298     if (jj_3R_436()) jj_scanpos = xsp;
35299     if (jj_scan_token(7)) return true;
35300     return false;
35301   }
35302 
35303   private boolean jj_3R_120() {
35304     if (jj_3R_196()) return true;
35305     if (jj_scan_token(4)) return true;
35306     return false;
35307   }
35308 
35309   private boolean jj_3R_204() {
35310     if (jj_scan_token(SELF)) return true;
35311     if (jj_scan_token(AS)) return true;
35312     if (jj_scan_token(RESULT)) return true;
35313     return false;
35314   }
35315 
35316   private boolean jj_3R_201() {
35317     if (jj_scan_token(DOUBLE)) return true;
35318     if (jj_scan_token(PRECISION)) return true;
35319     return false;
35320   }
35321 
35322   private boolean jj_3_32() {
35323     if (jj_scan_token(INTERVAL)) return true;
35324     if (jj_scan_token(DAY)) return true;
35325     return false;
35326   }
35327 
35328   private boolean jj_3_31() {
35329     if (jj_scan_token(INTERVAL)) return true;
35330     if (jj_scan_token(YEAR)) return true;
35331     return false;
35332   }
35333 
35334   private boolean jj_3R_563() {
35335     if (jj_scan_token(USING)) return true;
35336     Token xsp;
35337     xsp = jj_scanpos;
35338     if (jj_scan_token(398)) {
35339     jj_scanpos = xsp;
35340     if (jj_scan_token(399)) return true;
35341     }
35342     return false;
35343   }
35344 
35345   private boolean jj_3R_203() {
35346     if (jj_scan_token(REF)) return true;
35347     if (jj_scan_token(CURSOR)) return true;
35348     return false;
35349   }
35350 
35351   private boolean jj_3_57() {
35352     if (jj_3R_141()) return true;
35353     Token xsp;
35354     xsp = jj_scanpos;
35355     if (jj_scan_token(23)) {
35356     jj_scanpos = xsp;
35357     if (jj_scan_token(50)) return true;
35358     }
35359     return false;
35360   }
35361 
35362   private boolean jj_3R_431() {
35363     Token xsp;
35364     xsp = jj_scanpos;
35365     if (jj_3_57()) jj_scanpos = xsp;
35366     if (jj_3R_232()) return true;
35367     xsp = jj_scanpos;
35368     if (jj_3R_563()) jj_scanpos = xsp;
35369     return false;
35370   }
35371 
35372   private boolean jj_3_30() {
35373     if (jj_scan_token(LONG)) return true;
35374     if (jj_scan_token(RAW)) return true;
35375     return false;
35376   }
35377 
35378   private boolean jj_3R_530() {
35379     if (jj_scan_token(6)) return true;
35380     if (jj_3R_431()) return true;
35381     return false;
35382   }
35383 
35384   private boolean jj_3R_202() {
35385     Token xsp;
35386     xsp = jj_scanpos;
35387     if (jj_scan_token(66)) {
35388     jj_scanpos = xsp;
35389     if (jj_scan_token(317)) {
35390     jj_scanpos = xsp;
35391     if (jj_3_30()) {
35392     jj_scanpos = xsp;
35393     if (jj_scan_token(158)) {
35394     jj_scanpos = xsp;
35395     if (jj_scan_token(303)) {
35396     jj_scanpos = xsp;
35397     if (jj_scan_token(304)) {
35398     jj_scanpos = xsp;
35399     if (jj_scan_token(224)) {
35400     jj_scanpos = xsp;
35401     if (jj_scan_token(241)) {
35402     jj_scanpos = xsp;
35403     if (jj_scan_token(305)) {
35404     jj_scanpos = xsp;
35405     if (jj_scan_token(306)) {
35406     jj_scanpos = xsp;
35407     if (jj_scan_token(295)) {
35408     jj_scanpos = xsp;
35409     if (jj_scan_token(296)) {
35410     jj_scanpos = xsp;
35411     if (jj_scan_token(311)) {
35412     jj_scanpos = xsp;
35413     if (jj_scan_token(312)) return true;
35414     }
35415     }
35416     }
35417     }
35418     }
35419     }
35420     }
35421     }
35422     }
35423     }
35424     }
35425     }
35426     }
35427     return false;
35428   }
35429 
35430   private boolean jj_3R_390() {
35431     if (jj_3R_431()) return true;
35432     Token xsp;
35433     while (true) {
35434       xsp = jj_scanpos;
35435       if (jj_3R_530()) { jj_scanpos = xsp; break; }
35436     }
35437     return false;
35438   }
35439 
35440   private boolean jj_3R_340() {
35441     if (jj_3R_390()) return true;
35442     return false;
35443   }
35444 
35445   private boolean jj_3R_140() {
35446     if (jj_scan_token(11)) return true;
35447     return false;
35448   }
35449 
35450   private boolean jj_3R_297() {
35451     if (jj_scan_token(5)) return true;
35452     Token xsp;
35453     xsp = jj_scanpos;
35454     if (jj_3R_340()) jj_scanpos = xsp;
35455     if (jj_scan_token(7)) return true;
35456     return false;
35457   }
35458 
35459   private boolean jj_3R_125() {
35460     Token xsp;
35461     xsp = jj_scanpos;
35462     if (jj_scan_token(186)) {
35463     jj_scanpos = xsp;
35464     if (jj_scan_token(187)) {
35465     jj_scanpos = xsp;
35466     if (jj_scan_token(67)) {
35467     jj_scanpos = xsp;
35468     if (jj_scan_token(188)) {
35469     jj_scanpos = xsp;
35470     if (jj_scan_token(189)) {
35471     jj_scanpos = xsp;
35472     if (jj_scan_token(190)) {
35473     jj_scanpos = xsp;
35474     if (jj_scan_token(58)) {
35475     jj_scanpos = xsp;
35476     if (jj_scan_token(298)) {
35477     jj_scanpos = xsp;
35478     if (jj_scan_token(90)) {
35479     jj_scanpos = xsp;
35480     if (jj_3R_201()) {
35481     jj_scanpos = xsp;
35482     if (jj_scan_token(119)) {
35483     jj_scanpos = xsp;
35484     if (jj_scan_token(300)) {
35485     jj_scanpos = xsp;
35486     if (jj_scan_token(144)) {
35487     jj_scanpos = xsp;
35488     if (jj_scan_token(172)) {
35489     jj_scanpos = xsp;
35490     if (jj_scan_token(173)) {
35491     jj_scanpos = xsp;
35492     if (jj_scan_token(185)) {
35493     jj_scanpos = xsp;
35494     if (jj_scan_token(301)) {
35495     jj_scanpos = xsp;
35496     if (jj_scan_token(212)) {
35497     jj_scanpos = xsp;
35498     if (jj_scan_token(213)) {
35499     jj_scanpos = xsp;
35500     if (jj_scan_token(214)) {
35501     jj_scanpos = xsp;
35502     if (jj_scan_token(225)) {
35503     jj_scanpos = xsp;
35504     if (jj_scan_token(302)) {
35505     jj_scanpos = xsp;
35506     if (jj_scan_token(253)) {
35507     jj_scanpos = xsp;
35508     if (jj_3R_202()) {
35509     jj_scanpos = xsp;
35510     if (jj_scan_token(60)) {
35511     jj_scanpos = xsp;
35512     if (jj_scan_token(309)) {
35513     jj_scanpos = xsp;
35514     if (jj_scan_token(310)) {
35515     jj_scanpos = xsp;
35516     if (jj_scan_token(267)) {
35517     jj_scanpos = xsp;
35518     if (jj_3R_203()) {
35519     jj_scanpos = xsp;
35520     if (jj_scan_token(87)) {
35521     jj_scanpos = xsp;
35522     if (jj_3_31()) {
35523     jj_scanpos = xsp;
35524     if (jj_3_32()) {
35525     jj_scanpos = xsp;
35526     if (jj_scan_token(271)) {
35527     jj_scanpos = xsp;
35528     if (jj_scan_token(272)) {
35529     jj_scanpos = xsp;
35530     if (jj_3R_204()) return true;
35531     }
35532     }
35533     }
35534     }
35535     }
35536     }
35537     }
35538     }
35539     }
35540     }
35541     }
35542     }
35543     }
35544     }
35545     }
35546     }
35547     }
35548     }
35549     }
35550     }
35551     }
35552     }
35553     }
35554     }
35555     }
35556     }
35557     }
35558     }
35559     }
35560     }
35561     }
35562     }
35563     }
35564     }
35565     xsp = jj_scanpos;
35566     if (jj_3_33()) jj_scanpos = xsp;
35567     xsp = jj_scanpos;
35568     if (jj_3R_205()) jj_scanpos = xsp;
35569     return false;
35570   }
35571 
35572   private boolean jj_3R_350() {
35573     if (jj_scan_token(3)) return true;
35574     if (jj_3R_119()) return true;
35575     return false;
35576   }
35577 
35578   private boolean jj_3R_238() {
35579     if (jj_scan_token(VARYING)) return true;
35580     if (jj_scan_token(ARRAY)) return true;
35581     return false;
35582   }
35583 
35584   private boolean jj_3R_127() {
35585     if (jj_3R_141()) return true;
35586     Token xsp;
35587     while (true) {
35588       xsp = jj_scanpos;
35589       if (jj_3R_350()) { jj_scanpos = xsp; break; }
35590     }
35591     return false;
35592   }
35593 
35594   private boolean jj_3R_281() {
35595     Token xsp;
35596     xsp = jj_scanpos;
35597     if (jj_scan_token(116)) {
35598     jj_scanpos = xsp;
35599     if (jj_scan_token(280)) {
35600     jj_scanpos = xsp;
35601     if (jj_scan_token(293)) {
35602     jj_scanpos = xsp;
35603     if (jj_scan_token(374)) {
35604     jj_scanpos = xsp;
35605     if (jj_scan_token(43)) {
35606     jj_scanpos = xsp;
35607     if (jj_scan_token(318)) {
35608     jj_scanpos = xsp;
35609     if (jj_scan_token(44)) {
35610     jj_scanpos = xsp;
35611     if (jj_scan_token(341)) {
35612     jj_scanpos = xsp;
35613     if (jj_scan_token(342)) {
35614     jj_scanpos = xsp;
35615     if (jj_scan_token(52)) {
35616     jj_scanpos = xsp;
35617     if (jj_scan_token(386)) {
35618     jj_scanpos = xsp;
35619     if (jj_scan_token(53)) {
35620     jj_scanpos = xsp;
35621     if (jj_scan_token(343)) {
35622     jj_scanpos = xsp;
35623     if (jj_scan_token(405)) {
35624     jj_scanpos = xsp;
35625     if (jj_scan_token(54)) {
35626     jj_scanpos = xsp;
35627     if (jj_scan_token(319)) {
35628     jj_scanpos = xsp;
35629     if (jj_scan_token(309)) {
35630     jj_scanpos = xsp;
35631     if (jj_scan_token(310)) {
35632     jj_scanpos = xsp;
35633     if (jj_scan_token(392)) {
35634     jj_scanpos = xsp;
35635     if (jj_scan_token(61)) {
35636     jj_scanpos = xsp;
35637     if (jj_scan_token(63)) {
35638     jj_scanpos = xsp;
35639     if (jj_scan_token(346)) {
35640     jj_scanpos = xsp;
35641     if (jj_scan_token(64)) {
35642     jj_scanpos = xsp;
35643     if (jj_scan_token(387)) {
35644     jj_scanpos = xsp;
35645     if (jj_scan_token(398)) {
35646     jj_scanpos = xsp;
35647     if (jj_scan_token(317)) {
35648     jj_scanpos = xsp;
35649     if (jj_scan_token(373)) {
35650     jj_scanpos = xsp;
35651     if (jj_scan_token(372)) {
35652     jj_scanpos = xsp;
35653     if (jj_scan_token(311)) {
35654     jj_scanpos = xsp;
35655     if (jj_scan_token(69)) {
35656     jj_scanpos = xsp;
35657     if (jj_scan_token(71)) {
35658     jj_scanpos = xsp;
35659     if (jj_scan_token(72)) {
35660     jj_scanpos = xsp;
35661     if (jj_scan_token(73)) {
35662     jj_scanpos = xsp;
35663     if (jj_scan_token(74)) {
35664     jj_scanpos = xsp;
35665     if (jj_scan_token(75)) {
35666     jj_scanpos = xsp;
35667     if (jj_scan_token(344)) {
35668     jj_scanpos = xsp;
35669     if (jj_scan_token(79)) {
35670     jj_scanpos = xsp;
35671     if (jj_scan_token(367)) {
35672     jj_scanpos = xsp;
35673     if (jj_scan_token(80)) {
35674     jj_scanpos = xsp;
35675     if (jj_scan_token(81)) {
35676     jj_scanpos = xsp;
35677     if (jj_scan_token(376)) {
35678     jj_scanpos = xsp;
35679     if (jj_scan_token(83)) {
35680     jj_scanpos = xsp;
35681     if (jj_scan_token(37)) {
35682     jj_scanpos = xsp;
35683     if (jj_scan_token(85)) {
35684     jj_scanpos = xsp;
35685     if (jj_scan_token(86)) {
35686     jj_scanpos = xsp;
35687     if (jj_scan_token(345)) {
35688     jj_scanpos = xsp;
35689     if (jj_scan_token(88)) {
35690     jj_scanpos = xsp;
35691     if (jj_scan_token(403)) {
35692     jj_scanpos = xsp;
35693     if (jj_scan_token(347)) {
35694     jj_scanpos = xsp;
35695     if (jj_scan_token(298)) {
35696     jj_scanpos = xsp;
35697     if (jj_scan_token(377)) {
35698     jj_scanpos = xsp;
35699     if (jj_scan_token(36)) {
35700     jj_scanpos = xsp;
35701     if (jj_scan_token(408)) {
35702     jj_scanpos = xsp;
35703     if (jj_scan_token(95)) {
35704     jj_scanpos = xsp;
35705     if (jj_scan_token(348)) {
35706     jj_scanpos = xsp;
35707     if (jj_scan_token(378)) {
35708     jj_scanpos = xsp;
35709     if (jj_scan_token(297)) {
35710     jj_scanpos = xsp;
35711     if (jj_scan_token(349)) {
35712     jj_scanpos = xsp;
35713     if (jj_scan_token(100)) {
35714     jj_scanpos = xsp;
35715     if (jj_scan_token(393)) {
35716     jj_scanpos = xsp;
35717     if (jj_scan_token(103)) {
35718     jj_scanpos = xsp;
35719     if (jj_scan_token(105)) {
35720     jj_scanpos = xsp;
35721     if (jj_scan_token(106)) {
35722     jj_scanpos = xsp;
35723     if (jj_scan_token(108)) {
35724     jj_scanpos = xsp;
35725     if (jj_scan_token(112)) {
35726     jj_scanpos = xsp;
35727     if (jj_scan_token(114)) {
35728     jj_scanpos = xsp;
35729     if (jj_scan_token(113)) {
35730     jj_scanpos = xsp;
35731     if (jj_scan_token(115)) {
35732     jj_scanpos = xsp;
35733     if (jj_scan_token(118)) {
35734     jj_scanpos = xsp;
35735     if (jj_scan_token(350)) {
35736     jj_scanpos = xsp;
35737     if (jj_scan_token(122)) {
35738     jj_scanpos = xsp;
35739     if (jj_scan_token(124)) {
35740     jj_scanpos = xsp;
35741     if (jj_scan_token(125)) {
35742     jj_scanpos = xsp;
35743     if (jj_scan_token(129)) {
35744     jj_scanpos = xsp;
35745     if (jj_scan_token(131)) {
35746     jj_scanpos = xsp;
35747     if (jj_scan_token(379)) {
35748     jj_scanpos = xsp;
35749     if (jj_scan_token(132)) {
35750     jj_scanpos = xsp;
35751     if (jj_scan_token(135)) {
35752     jj_scanpos = xsp;
35753     if (jj_scan_token(140)) {
35754     jj_scanpos = xsp;
35755     if (jj_scan_token(141)) {
35756     jj_scanpos = xsp;
35757     if (jj_scan_token(138)) {
35758     jj_scanpos = xsp;
35759     if (jj_scan_token(143)) {
35760     jj_scanpos = xsp;
35761     if (jj_scan_token(147)) {
35762     jj_scanpos = xsp;
35763     if (jj_scan_token(149)) {
35764     jj_scanpos = xsp;
35765     if (jj_scan_token(151)) {
35766     jj_scanpos = xsp;
35767     if (jj_scan_token(152)) {
35768     jj_scanpos = xsp;
35769     if (jj_scan_token(42)) {
35770     jj_scanpos = xsp;
35771     if (jj_scan_token(396)) {
35772     jj_scanpos = xsp;
35773     if (jj_scan_token(390)) {
35774     jj_scanpos = xsp;
35775     if (jj_scan_token(369)) {
35776     jj_scanpos = xsp;
35777     if (jj_scan_token(153)) {
35778     jj_scanpos = xsp;
35779     if (jj_scan_token(364)) {
35780     jj_scanpos = xsp;
35781     if (jj_scan_token(155)) {
35782     jj_scanpos = xsp;
35783     if (jj_scan_token(406)) {
35784     jj_scanpos = xsp;
35785     if (jj_scan_token(314)) {
35786     jj_scanpos = xsp;
35787     if (jj_scan_token(351)) {
35788     jj_scanpos = xsp;
35789     if (jj_scan_token(352)) {
35790     jj_scanpos = xsp;
35791     if (jj_scan_token(160)) {
35792     jj_scanpos = xsp;
35793     if (jj_scan_token(161)) {
35794     jj_scanpos = xsp;
35795     if (jj_scan_token(371)) {
35796     jj_scanpos = xsp;
35797     if (jj_scan_token(162)) {
35798     jj_scanpos = xsp;
35799     if (jj_scan_token(163)) {
35800     jj_scanpos = xsp;
35801     if (jj_scan_token(164)) {
35802     jj_scanpos = xsp;
35803     if (jj_scan_token(166)) {
35804     jj_scanpos = xsp;
35805     if (jj_scan_token(167)) {
35806     jj_scanpos = xsp;
35807     if (jj_scan_token(168)) {
35808     jj_scanpos = xsp;
35809     if (jj_scan_token(171)) {
35810     jj_scanpos = xsp;
35811     if (jj_scan_token(394)) {
35812     jj_scanpos = xsp;
35813     if (jj_scan_token(365)) {
35814     jj_scanpos = xsp;
35815     if (jj_scan_token(172)) {
35816     jj_scanpos = xsp;
35817     if (jj_scan_token(303)) {
35818     jj_scanpos = xsp;
35819     if (jj_scan_token(399)) {
35820     jj_scanpos = xsp;
35821     if (jj_scan_token(312)) {
35822     jj_scanpos = xsp;
35823     if (jj_scan_token(353)) {
35824     jj_scanpos = xsp;
35825     if (jj_scan_token(174)) {
35826     jj_scanpos = xsp;
35827     if (jj_scan_token(177)) {
35828     jj_scanpos = xsp;
35829     if (jj_scan_token(354)) {
35830     jj_scanpos = xsp;
35831     if (jj_scan_token(301)) {
35832     jj_scanpos = xsp;
35833     if (jj_scan_token(304)) {
35834     jj_scanpos = xsp;
35835     if (jj_scan_token(191)) {
35836     jj_scanpos = xsp;
35837     if (jj_scan_token(194)) {
35838     jj_scanpos = xsp;
35839     if (jj_scan_token(323)) {
35840     jj_scanpos = xsp;
35841     if (jj_scan_token(196)) {
35842     jj_scanpos = xsp;
35843     if (jj_scan_token(197)) {
35844     jj_scanpos = xsp;
35845     if (jj_scan_token(202)) {
35846     jj_scanpos = xsp;
35847     if (jj_scan_token(203)) {
35848     jj_scanpos = xsp;
35849     if (jj_scan_token(205)) {
35850     jj_scanpos = xsp;
35851     if (jj_scan_token(206)) {
35852     jj_scanpos = xsp;
35853     if (jj_scan_token(368)) {
35854     jj_scanpos = xsp;
35855     if (jj_scan_token(324)) {
35856     jj_scanpos = xsp;
35857     if (jj_scan_token(208)) {
35858     jj_scanpos = xsp;
35859     if (jj_scan_token(299)) {
35860     jj_scanpos = xsp;
35861     if (jj_scan_token(216)) {
35862     jj_scanpos = xsp;
35863     if (jj_scan_token(380)) {
35864     jj_scanpos = xsp;
35865     if (jj_scan_token(220)) {
35866     jj_scanpos = xsp;
35867     if (jj_scan_token(381)) {
35868     jj_scanpos = xsp;
35869     if (jj_scan_token(223)) {
35870     jj_scanpos = xsp;
35871     if (jj_scan_token(225)) {
35872     jj_scanpos = xsp;
35873     if (jj_scan_token(226)) {
35874     jj_scanpos = xsp;
35875     if (jj_scan_token(227)) {
35876     jj_scanpos = xsp;
35877     if (jj_scan_token(229)) {
35878     jj_scanpos = xsp;
35879     if (jj_scan_token(382)) {
35880     jj_scanpos = xsp;
35881     if (jj_scan_token(232)) {
35882     jj_scanpos = xsp;
35883     if (jj_scan_token(234)) {
35884     jj_scanpos = xsp;
35885     if (jj_scan_token(235)) {
35886     jj_scanpos = xsp;
35887     if (jj_scan_token(236)) {
35888     jj_scanpos = xsp;
35889     if (jj_scan_token(391)) {
35890     jj_scanpos = xsp;
35891     if (jj_scan_token(238)) {
35892     jj_scanpos = xsp;
35893     if (jj_scan_token(239)) {
35894     jj_scanpos = xsp;
35895     if (jj_scan_token(241)) {
35896     jj_scanpos = xsp;
35897     if (jj_scan_token(242)) {
35898     jj_scanpos = xsp;
35899     if (jj_scan_token(240)) {
35900     jj_scanpos = xsp;
35901     if (jj_scan_token(244)) {
35902     jj_scanpos = xsp;
35903     if (jj_scan_token(245)) {
35904     jj_scanpos = xsp;
35905     if (jj_scan_token(355)) {
35906     jj_scanpos = xsp;
35907     if (jj_scan_token(246)) {
35908     jj_scanpos = xsp;
35909     if (jj_scan_token(248)) {
35910     jj_scanpos = xsp;
35911     if (jj_scan_token(356)) {
35912     jj_scanpos = xsp;
35913     if (jj_scan_token(404)) {
35914     jj_scanpos = xsp;
35915     if (jj_scan_token(250)) {
35916     jj_scanpos = xsp;
35917     if (jj_scan_token(407)) {
35918     jj_scanpos = xsp;
35919     if (jj_scan_token(357)) {
35920     jj_scanpos = xsp;
35921     if (jj_scan_token(254)) {
35922     jj_scanpos = xsp;
35923     if (jj_scan_token(358)) {
35924     jj_scanpos = xsp;
35925     if (jj_scan_token(359)) {
35926     jj_scanpos = xsp;
35927     if (jj_scan_token(259)) {
35928     jj_scanpos = xsp;
35929     if (jj_scan_token(360)) {
35930     jj_scanpos = xsp;
35931     if (jj_scan_token(366)) {
35932     jj_scanpos = xsp;
35933     if (jj_scan_token(395)) {
35934     jj_scanpos = xsp;
35935     if (jj_scan_token(262)) {
35936     jj_scanpos = xsp;
35937     if (jj_scan_token(261)) {
35938     jj_scanpos = xsp;
35939     if (jj_scan_token(263)) {
35940     jj_scanpos = xsp;
35941     if (jj_scan_token(361)) {
35942     jj_scanpos = xsp;
35943     if (jj_scan_token(370)) {
35944     jj_scanpos = xsp;
35945     if (jj_scan_token(269)) {
35946     jj_scanpos = xsp;
35947     if (jj_scan_token(271)) {
35948     jj_scanpos = xsp;
35949     if (jj_scan_token(272)) {
35950     jj_scanpos = xsp;
35951     if (jj_scan_token(274)) {
35952     jj_scanpos = xsp;
35953     if (jj_scan_token(276)) {
35954     jj_scanpos = xsp;
35955     if (jj_scan_token(275)) {
35956     jj_scanpos = xsp;
35957     if (jj_scan_token(273)) {
35958     jj_scanpos = xsp;
35959     if (jj_scan_token(397)) {
35960     jj_scanpos = xsp;
35961     if (jj_scan_token(278)) {
35962     jj_scanpos = xsp;
35963     if (jj_scan_token(388)) {
35964     jj_scanpos = xsp;
35965     if (jj_scan_token(389)) {
35966     jj_scanpos = xsp;
35967     if (jj_scan_token(362)) {
35968     jj_scanpos = xsp;
35969     if (jj_scan_token(383)) {
35970     jj_scanpos = xsp;
35971     if (jj_scan_token(283)) {
35972     jj_scanpos = xsp;
35973     if (jj_scan_token(306)) {
35974     jj_scanpos = xsp;
35975     if (jj_scan_token(409)) {
35976     jj_scanpos = xsp;
35977     if (jj_scan_token(285)) {
35978     jj_scanpos = xsp;
35979     if (jj_scan_token(307)) {
35980     jj_scanpos = xsp;
35981     if (jj_scan_token(384)) {
35982     jj_scanpos = xsp;
35983     if (jj_scan_token(308)) {
35984     jj_scanpos = xsp;
35985     if (jj_scan_token(385)) {
35986     jj_scanpos = xsp;
35987     if (jj_scan_token(313)) {
35988     jj_scanpos = xsp;
35989     if (jj_scan_token(290)) {
35990     jj_scanpos = xsp;
35991     if (jj_scan_token(316)) {
35992     jj_scanpos = xsp;
35993     if (jj_scan_token(291)) {
35994     jj_scanpos = xsp;
35995     if (jj_scan_token(363)) {
35996     jj_scanpos = xsp;
35997     if (jj_scan_token(267)) {
35998     jj_scanpos = xsp;
35999     if (jj_scan_token(99)) {
36000     jj_scanpos = xsp;
36001     if (jj_scan_token(180)) {
36002     jj_scanpos = xsp;
36003     if (jj_scan_token(375)) {
36004     jj_scanpos = xsp;
36005     if (jj_scan_token(184)) {
36006     jj_scanpos = xsp;
36007     if (jj_scan_token(230)) {
36008     jj_scanpos = xsp;
36009     if (jj_scan_token(228)) return true;
36010     }
36011     }
36012     }
36013     }
36014     }
36015     }
36016     }
36017     }
36018     }
36019     }
36020     }
36021     }
36022     }
36023     }
36024     }
36025     }
36026     }
36027     }
36028     }
36029     }
36030     }
36031     }
36032     }
36033     }
36034     }
36035     }
36036     }
36037     }
36038     }
36039     }
36040     }
36041     }
36042     }
36043     }
36044     }
36045     }
36046     }
36047     }
36048     }
36049     }
36050     }
36051     }
36052     }
36053     }
36054     }
36055     }
36056     }
36057     }
36058     }
36059     }
36060     }
36061     }
36062     }
36063     }
36064     }
36065     }
36066     }
36067     }
36068     }
36069     }
36070     }
36071     }
36072     }
36073     }
36074     }
36075     }
36076     }
36077     }
36078     }
36079     }
36080     }
36081     }
36082     }
36083     }
36084     }
36085     }
36086     }
36087     }
36088     }
36089     }
36090     }
36091     }
36092     }
36093     }
36094     }
36095     }
36096     }
36097     }
36098     }
36099     }
36100     }
36101     }
36102     }
36103     }
36104     }
36105     }
36106     }
36107     }
36108     }
36109     }
36110     }
36111     }
36112     }
36113     }
36114     }
36115     }
36116     }
36117     }
36118     }
36119     }
36120     }
36121     }
36122     }
36123     }
36124     }
36125     }
36126     }
36127     }
36128     }
36129     }
36130     }
36131     }
36132     }
36133     }
36134     }
36135     }
36136     }
36137     }
36138     }
36139     }
36140     }
36141     }
36142     }
36143     }
36144     }
36145     }
36146     }
36147     }
36148     }
36149     }
36150     }
36151     }
36152     }
36153     }
36154     }
36155     }
36156     }
36157     }
36158     }
36159     }
36160     }
36161     }
36162     }
36163     }
36164     }
36165     }
36166     }
36167     }
36168     }
36169     }
36170     }
36171     }
36172     }
36173     }
36174     }
36175     }
36176     }
36177     }
36178     }
36179     }
36180     }
36181     }
36182     }
36183     }
36184     }
36185     }
36186     }
36187     }
36188     }
36189     }
36190     }
36191     }
36192     }
36193     }
36194     }
36195     }
36196     }
36197     }
36198     }
36199     }
36200     }
36201     }
36202     }
36203     }
36204     }
36205     }
36206     }
36207     }
36208     }
36209     }
36210     }
36211     }
36212     }
36213     }
36214     }
36215     }
36216     return false;
36217   }
36218 
36219   private boolean jj_3_29() {
36220     if (jj_scan_token(5)) return true;
36221     if (jj_3R_126()) return true;
36222     return false;
36223   }
36224 
36225   private boolean jj_3R_139() {
36226     if (jj_scan_token(3)) return true;
36227     return false;
36228   }
36229 
36230   private boolean jj_3_56() {
36231     Token xsp;
36232     xsp = jj_scanpos;
36233     if (jj_3R_139()) {
36234     jj_scanpos = xsp;
36235     if (jj_3R_140()) return true;
36236     }
36237     if (jj_3R_119()) return true;
36238     return false;
36239   }
36240 
36241   private boolean jj_3R_144() {
36242     Token xsp;
36243     xsp = jj_scanpos;
36244     if (jj_scan_token(268)) {
36245     jj_scanpos = xsp;
36246     if (jj_scan_token(307)) {
36247     jj_scanpos = xsp;
36248     if (jj_3R_238()) return true;
36249     }
36250     }
36251     xsp = jj_scanpos;
36252     if (jj_3_29()) jj_scanpos = xsp;
36253     return false;
36254   }
36255 
36256   private boolean jj_3R_293() {
36257     if (jj_3R_141()) return true;
36258     Token xsp;
36259     while (true) {
36260       xsp = jj_scanpos;
36261       if (jj_3_56()) { jj_scanpos = xsp; break; }
36262     }
36263     return false;
36264   }
36265 
36266   private boolean jj_3R_396() {
36267     if (jj_scan_token(CC_ELSE)) return true;
36268     if (jj_3R_234()) return true;
36269     return false;
36270   }
36271 
36272   private boolean jj_3R_189() {
36273     if (jj_scan_token(21)) return true;
36274     if (jj_3R_141()) return true;
36275     if (jj_scan_token(22)) return true;
36276     return false;
36277   }
36278 
36279   private boolean jj_3R_395() {
36280     if (jj_scan_token(CC_ELSIF)) return true;
36281     if (jj_3R_342()) return true;
36282     if (jj_scan_token(CC_THEN)) return true;
36283     if (jj_3R_234()) return true;
36284     return false;
36285   }
36286 
36287   private boolean jj_3R_344() {
36288     if (jj_scan_token(CC_IF)) return true;
36289     if (jj_3R_342()) return true;
36290     if (jj_scan_token(CC_THEN)) return true;
36291     if (jj_3R_234()) return true;
36292     Token xsp;
36293     while (true) {
36294       xsp = jj_scanpos;
36295       if (jj_3R_395()) { jj_scanpos = xsp; break; }
36296     }
36297     while (true) {
36298       xsp = jj_scanpos;
36299       if (jj_3R_396()) { jj_scanpos = xsp; break; }
36300     }
36301     if (jj_scan_token(CC_END)) return true;
36302     return false;
36303   }
36304 
36305   private boolean jj_3R_346() {
36306     if (jj_scan_token(11)) return true;
36307     Token xsp;
36308     xsp = jj_scanpos;
36309     if (jj_scan_token(281)) {
36310     jj_scanpos = xsp;
36311     if (jj_scan_token(243)) return true;
36312     }
36313     return false;
36314   }
36315 
36316   private boolean jj_3R_345() {
36317     if (jj_scan_token(2)) return true;
36318     if (jj_3R_127()) return true;
36319     return false;
36320   }
36321 
36322   private boolean jj_3R_126() {
36323     if (jj_scan_token(UNSIGNED_NUMERIC_LITERAL)) return true;
36324     return false;
36325   }
36326 
36327   private boolean jj_3_27() {
36328     if (jj_scan_token(REF)) return true;
36329     return false;
36330   }
36331 
36332   private boolean jj_3R_303() {
36333     Token xsp;
36334     xsp = jj_scanpos;
36335     if (jj_3_27()) jj_scanpos = xsp;
36336     if (jj_3R_127()) return true;
36337     xsp = jj_scanpos;
36338     if (jj_3R_345()) jj_scanpos = xsp;
36339     xsp = jj_scanpos;
36340     if (jj_3R_346()) jj_scanpos = xsp;
36341     return false;
36342   }
36343 
36344   private boolean jj_3_28() {
36345     if (jj_3R_125()) return true;
36346     return false;
36347   }
36348 
36349   private boolean jj_3R_302() {
36350     if (jj_3R_344()) return true;
36351     return false;
36352   }
36353 
36354   private boolean jj_3R_234() {
36355     Token xsp;
36356     xsp = jj_scanpos;
36357     if (jj_3R_302()) {
36358     jj_scanpos = xsp;
36359     if (jj_3_28()) {
36360     jj_scanpos = xsp;
36361     if (jj_3R_303()) return true;
36362     }
36363     }
36364     return false;
36365   }
36366 
36367   private boolean jj_3R_225() {
36368     if (jj_scan_token(A)) return true;
36369     if (jj_scan_token(SET)) return true;
36370     return false;
36371   }
36372 
36373   private boolean jj_3R_135() {
36374     Token xsp;
36375     xsp = jj_scanpos;
36376     if (jj_3R_225()) {
36377     jj_scanpos = xsp;
36378     if (jj_scan_token(393)) return true;
36379     }
36380     return false;
36381   }
36382 
36383   private boolean jj_3R_333() {
36384     if (jj_scan_token(_DEFAULT)) return true;
36385     return false;
36386   }
36387 
36388   private boolean jj_3R_388() {
36389     if (jj_scan_token(NULL)) return true;
36390     return false;
36391   }
36392 
36393   private boolean jj_3R_334() {
36394     if (jj_3R_232()) return true;
36395     return false;
36396   }
36397 
36398   private boolean jj_3R_282() {
36399     if (jj_3R_123()) return true;
36400     return false;
36401   }
36402 
36403   private boolean jj_3R_387() {
36404     Token xsp;
36405     xsp = jj_scanpos;
36406     if (jj_scan_token(280)) {
36407     jj_scanpos = xsp;
36408     if (jj_scan_token(116)) return true;
36409     }
36410     return false;
36411   }
36412 
36413   private boolean jj_3R_332() {
36414     if (jj_scan_token(9)) return true;
36415     if (jj_scan_token(10)) return true;
36416     return false;
36417   }
36418 
36419   private boolean jj_3R_284() {
36420     Token xsp;
36421     xsp = jj_scanpos;
36422     if (jj_3R_332()) {
36423     jj_scanpos = xsp;
36424     if (jj_3R_333()) return true;
36425     }
36426     if (jj_3R_334()) return true;
36427     return false;
36428   }
36429 
36430   private boolean jj_3R_331() {
36431     if (jj_scan_token(NOT)) return true;
36432     return false;
36433   }
36434 
36435   private boolean jj_3R_283() {
36436     Token xsp;
36437     xsp = jj_scanpos;
36438     if (jj_3R_331()) jj_scanpos = xsp;
36439     if (jj_scan_token(NULL)) return true;
36440     return false;
36441   }
36442 
36443   private boolean jj_3_26() {
36444     if (jj_scan_token(CONSTANT)) return true;
36445     return false;
36446   }
36447 
36448   private boolean jj_3R_196() {
36449     if (jj_3R_282()) return true;
36450     Token xsp;
36451     xsp = jj_scanpos;
36452     if (jj_3_26()) jj_scanpos = xsp;
36453     if (jj_3R_234()) return true;
36454     xsp = jj_scanpos;
36455     if (jj_3R_283()) jj_scanpos = xsp;
36456     xsp = jj_scanpos;
36457     if (jj_3R_284()) jj_scanpos = xsp;
36458     return false;
36459   }
36460 
36461   private boolean jj_3R_509() {
36462     if (jj_scan_token(6)) return true;
36463     if (jj_3R_469()) return true;
36464     return false;
36465   }
36466 
36467   private boolean jj_3R_423() {
36468     if (jj_3R_469()) return true;
36469     Token xsp;
36470     while (true) {
36471       xsp = jj_scanpos;
36472       if (jj_3R_509()) { jj_scanpos = xsp; break; }
36473     }
36474     return false;
36475   }
36476 
36477   private boolean jj_3R_382() {
36478     if (jj_scan_token(5)) return true;
36479     Token xsp;
36480     xsp = jj_scanpos;
36481     if (jj_3R_423()) jj_scanpos = xsp;
36482     if (jj_scan_token(7)) return true;
36483     return false;
36484   }
36485 
36486   private boolean jj_3_23() {
36487     if (jj_scan_token(NOCOPY)) return true;
36488     return false;
36489   }
36490 
36491   private boolean jj_3R_324() {
36492     if (jj_3R_382()) return true;
36493     return false;
36494   }
36495 
36496   private boolean jj_3R_458() {
36497     if (jj_3R_123()) return true;
36498     return false;
36499   }
36500 
36501   private boolean jj_3R_323() {
36502     if (jj_scan_token(RETURN)) return true;
36503     if (jj_3R_234()) return true;
36504     return false;
36505   }
36506 
36507   private boolean jj_3R_277() {
36508     if (jj_scan_token(PROCEDURE)) return true;
36509     if (jj_3R_153()) return true;
36510     Token xsp;
36511     xsp = jj_scanpos;
36512     if (jj_3R_324()) jj_scanpos = xsp;
36513     return false;
36514   }
36515 
36516   private boolean jj_3R_181() {
36517     if (jj_scan_token(STRING_LITERAL)) return true;
36518     return false;
36519   }
36520 
36521   private boolean jj_3R_124() {
36522     if (jj_scan_token(IN)) return true;
36523     if (jj_scan_token(OUT)) return true;
36524     return false;
36525   }
36526 
36527   private boolean jj_3R_322() {
36528     if (jj_3R_382()) return true;
36529     return false;
36530   }
36531 
36532   private boolean jj_3R_618() {
36533     if (jj_scan_token(3)) return true;
36534     if (jj_3R_123()) return true;
36535     return false;
36536   }
36537 
36538   private boolean jj_3R_276() {
36539     if (jj_scan_token(FUNCTION)) return true;
36540     if (jj_3R_153()) return true;
36541     Token xsp;
36542     xsp = jj_scanpos;
36543     if (jj_3R_322()) jj_scanpos = xsp;
36544     xsp = jj_scanpos;
36545     if (jj_3R_323()) jj_scanpos = xsp;
36546     return false;
36547   }
36548 
36549   private boolean jj_3R_617() {
36550     if (jj_scan_token(6)) return true;
36551     if (jj_3R_123()) return true;
36552     return false;
36553   }
36554 
36555   private boolean jj_3R_457() {
36556     if (jj_3R_348()) return true;
36557     return false;
36558   }
36559 
36560   private boolean jj_3R_192() {
36561     Token xsp;
36562     xsp = jj_scanpos;
36563     if (jj_3R_276()) {
36564     jj_scanpos = xsp;
36565     if (jj_3R_277()) return true;
36566     }
36567     return false;
36568   }
36569 
36570   private boolean jj_3R_339() {
36571     if (jj_3R_389()) return true;
36572     return false;
36573   }
36574 
36575   private boolean jj_3_24() {
36576     Token xsp;
36577     xsp = jj_scanpos;
36578     if (jj_scan_token(204)) {
36579     jj_scanpos = xsp;
36580     if (jj_3R_124()) return true;
36581     }
36582     xsp = jj_scanpos;
36583     if (jj_3_23()) jj_scanpos = xsp;
36584     return false;
36585   }
36586 
36587   private boolean jj_3R_338() {
36588     if (jj_3R_388()) return true;
36589     return false;
36590   }
36591 
36592   private boolean jj_3R_337() {
36593     if (jj_3R_387()) return true;
36594     return false;
36595   }
36596 
36597   private boolean jj_3R_554() {
36598     if (jj_3R_234()) return true;
36599     return false;
36600   }
36601 
36602   private boolean jj_3R_596() {
36603     if (jj_scan_token(6)) return true;
36604     if (jj_3R_123()) return true;
36605     Token xsp;
36606     xsp = jj_scanpos;
36607     if (jj_3R_618()) jj_scanpos = xsp;
36608     return false;
36609   }
36610 
36611   private boolean jj_3R_481() {
36612     if (jj_scan_token(3)) return true;
36613     if (jj_3R_123()) return true;
36614     return false;
36615   }
36616 
36617   private boolean jj_3R_336() {
36618     if (jj_3R_181()) return true;
36619     return false;
36620   }
36621 
36622   private boolean jj_3R_465() {
36623     if (jj_3R_145()) return true;
36624     return false;
36625   }
36626 
36627   private boolean jj_3R_195() {
36628     if (jj_3R_281()) return true;
36629     return false;
36630   }
36631 
36632   private boolean jj_3R_464() {
36633     if (jj_3R_117()) return true;
36634     return false;
36635   }
36636 
36637   private boolean jj_3R_335() {
36638     if (jj_3R_126()) return true;
36639     return false;
36640   }
36641 
36642   private boolean jj_3R_421() {
36643     Token xsp;
36644     xsp = jj_scanpos;
36645     if (jj_3R_464()) {
36646     jj_scanpos = xsp;
36647     if (jj_3R_465()) return true;
36648     }
36649     return false;
36650   }
36651 
36652   private boolean jj_3R_292() {
36653     Token xsp;
36654     xsp = jj_scanpos;
36655     if (jj_3R_335()) {
36656     jj_scanpos = xsp;
36657     if (jj_scan_token(422)) {
36658     jj_scanpos = xsp;
36659     if (jj_3R_336()) {
36660     jj_scanpos = xsp;
36661     if (jj_3R_337()) {
36662     jj_scanpos = xsp;
36663     if (jj_3R_338()) {
36664     jj_scanpos = xsp;
36665     if (jj_3R_339()) return true;
36666     }
36667     }
36668     }
36669     }
36670     }
36671     return false;
36672   }
36673 
36674   private boolean jj_3R_592() {
36675     if (jj_scan_token(9)) return true;
36676     if (jj_scan_token(10)) return true;
36677     return false;
36678   }
36679 
36680   private boolean jj_3R_456() {
36681     if (jj_3R_172()) return true;
36682     return false;
36683   }
36684 
36685   private boolean jj_3R_555() {
36686     Token xsp;
36687     xsp = jj_scanpos;
36688     if (jj_3R_592()) {
36689     jj_scanpos = xsp;
36690     if (jj_scan_token(91)) return true;
36691     }
36692     if (jj_3R_232()) return true;
36693     return false;
36694   }
36695 
36696   private boolean jj_3R_473() {
36697     if (jj_3R_232()) return true;
36698     return false;
36699   }
36700 
36701   private boolean jj_3R_472() {
36702     if (jj_3R_181()) return true;
36703     return false;
36704   }
36705 
36706   private boolean jj_3R_471() {
36707     if (jj_scan_token(SESSIONTIMEZONE)) return true;
36708     return false;
36709   }
36710 
36711   private boolean jj_3_25() {
36712     Token xsp;
36713     xsp = jj_scanpos;
36714     if (jj_3_24()) {
36715     jj_scanpos = xsp;
36716     if (jj_scan_token(136)) return true;
36717     }
36718     return false;
36719   }
36720 
36721   private boolean jj_3R_470() {
36722     if (jj_scan_token(DBTIMEZONE)) return true;
36723     return false;
36724   }
36725 
36726   private boolean jj_3R_595() {
36727     if (jj_scan_token(3)) return true;
36728     if (jj_3R_123()) return true;
36729     return false;
36730   }
36731 
36732   private boolean jj_3R_511() {
36733     if (jj_3R_123()) return true;
36734     return false;
36735   }
36736 
36737   private boolean jj_3R_384() {
36738     if (jj_scan_token(USING)) return true;
36739     if (jj_3R_123()) return true;
36740     Token xsp;
36741     xsp = jj_scanpos;
36742     if (jj_3R_481()) jj_scanpos = xsp;
36743     return false;
36744   }
36745 
36746   private boolean jj_3R_119() {
36747     Token xsp;
36748     xsp = jj_scanpos;
36749     if (jj_scan_token(417)) {
36750     jj_scanpos = xsp;
36751     if (jj_scan_token(425)) {
36752     jj_scanpos = xsp;
36753     if (jj_3R_195()) {
36754     jj_scanpos = xsp;
36755     if (jj_scan_token(35)) {
36756     jj_scanpos = xsp;
36757     if (jj_scan_token(38)) {
36758     jj_scanpos = xsp;
36759     if (jj_scan_token(39)) {
36760     jj_scanpos = xsp;
36761     if (jj_scan_token(40)) {
36762     jj_scanpos = xsp;
36763     if (jj_scan_token(41)) {
36764     jj_scanpos = xsp;
36765     if (jj_scan_token(49)) {
36766     jj_scanpos = xsp;
36767     if (jj_scan_token(55)) {
36768     jj_scanpos = xsp;
36769     if (jj_scan_token(58)) {
36770     jj_scanpos = xsp;
36771     if (jj_scan_token(59)) {
36772     jj_scanpos = xsp;
36773     if (jj_scan_token(60)) {
36774     jj_scanpos = xsp;
36775     if (jj_scan_token(66)) {
36776     jj_scanpos = xsp;
36777     if (jj_scan_token(67)) {
36778     jj_scanpos = xsp;
36779     if (jj_scan_token(78)) {
36780     jj_scanpos = xsp;
36781     if (jj_scan_token(84)) {
36782     jj_scanpos = xsp;
36783     if (jj_scan_token(87)) {
36784     jj_scanpos = xsp;
36785     if (jj_scan_token(90)) {
36786     jj_scanpos = xsp;
36787     if (jj_scan_token(92)) {
36788     jj_scanpos = xsp;
36789     if (jj_scan_token(97)) {
36790     jj_scanpos = xsp;
36791     if (jj_scan_token(102)) {
36792     jj_scanpos = xsp;
36793     if (jj_scan_token(110)) {
36794     jj_scanpos = xsp;
36795     if (jj_scan_token(111)) {
36796     jj_scanpos = xsp;
36797     if (jj_scan_token(119)) {
36798     jj_scanpos = xsp;
36799     if (jj_scan_token(121)) {
36800     jj_scanpos = xsp;
36801     if (jj_scan_token(144)) {
36802     jj_scanpos = xsp;
36803     if (jj_scan_token(145)) {
36804     jj_scanpos = xsp;
36805     if (jj_scan_token(158)) {
36806     jj_scanpos = xsp;
36807     if (jj_scan_token(159)) {
36808     jj_scanpos = xsp;
36809     if (jj_scan_token(169)) {
36810     jj_scanpos = xsp;
36811     if (jj_scan_token(173)) {
36812     jj_scanpos = xsp;
36813     if (jj_scan_token(176)) {
36814     jj_scanpos = xsp;
36815     if (jj_scan_token(179)) {
36816     jj_scanpos = xsp;
36817     if (jj_scan_token(185)) {
36818     jj_scanpos = xsp;
36819     if (jj_scan_token(186)) {
36820     jj_scanpos = xsp;
36821     if (jj_scan_token(187)) {
36822     jj_scanpos = xsp;
36823     if (jj_scan_token(188)) {
36824     jj_scanpos = xsp;
36825     if (jj_scan_token(189)) {
36826     jj_scanpos = xsp;
36827     if (jj_scan_token(190)) {
36828     jj_scanpos = xsp;
36829     if (jj_scan_token(192)) {
36830     jj_scanpos = xsp;
36831     if (jj_scan_token(198)) {
36832     jj_scanpos = xsp;
36833     if (jj_scan_token(204)) {
36834     jj_scanpos = xsp;
36835     if (jj_scan_token(212)) {
36836     jj_scanpos = xsp;
36837     if (jj_scan_token(213)) {
36838     jj_scanpos = xsp;
36839     if (jj_scan_token(214)) {
36840     jj_scanpos = xsp;
36841     if (jj_scan_token(215)) {
36842     jj_scanpos = xsp;
36843     if (jj_scan_token(217)) {
36844     jj_scanpos = xsp;
36845     if (jj_scan_token(219)) {
36846     jj_scanpos = xsp;
36847     if (jj_scan_token(218)) {
36848     jj_scanpos = xsp;
36849     if (jj_scan_token(222)) {
36850     jj_scanpos = xsp;
36851     if (jj_scan_token(224)) {
36852     jj_scanpos = xsp;
36853     if (jj_scan_token(243)) {
36854     jj_scanpos = xsp;
36855     if (jj_scan_token(249)) {
36856     jj_scanpos = xsp;
36857     if (jj_scan_token(253)) {
36858     jj_scanpos = xsp;
36859     if (jj_scan_token(256)) {
36860     jj_scanpos = xsp;
36861     if (jj_scan_token(257)) {
36862     jj_scanpos = xsp;
36863     if (jj_scan_token(260)) {
36864     jj_scanpos = xsp;
36865     if (jj_scan_token(264)) {
36866     jj_scanpos = xsp;
36867     if (jj_scan_token(265)) {
36868     jj_scanpos = xsp;
36869     if (jj_scan_token(266)) {
36870     jj_scanpos = xsp;
36871     if (jj_scan_token(279)) {
36872     jj_scanpos = xsp;
36873     if (jj_scan_token(281)) {
36874     jj_scanpos = xsp;
36875     if (jj_scan_token(282)) {
36876     jj_scanpos = xsp;
36877     if (jj_scan_token(295)) {
36878     jj_scanpos = xsp;
36879     if (jj_scan_token(296)) {
36880     jj_scanpos = xsp;
36881     if (jj_scan_token(300)) {
36882     jj_scanpos = xsp;
36883     if (jj_scan_token(302)) {
36884     jj_scanpos = xsp;
36885     if (jj_scan_token(305)) {
36886     jj_scanpos = xsp;
36887     if (jj_scan_token(289)) return true;
36888     }
36889     }
36890     }
36891     }
36892     }
36893     }
36894     }
36895     }
36896     }
36897     }
36898     }
36899     }
36900     }
36901     }
36902     }
36903     }
36904     }
36905     }
36906     }
36907     }
36908     }
36909     }
36910     }
36911     }
36912     }
36913     }
36914     }
36915     }
36916     }
36917     }
36918     }
36919     }
36920     }
36921     }
36922     }
36923     }
36924     }
36925     }
36926     }
36927     }
36928     }
36929     }
36930     }
36931     }
36932     }
36933     }
36934     }
36935     }
36936     }
36937     }
36938     }
36939     }
36940     }
36941     }
36942     }
36943     }
36944     }
36945     }
36946     }
36947     }
36948     }
36949     }
36950     }
36951     }
36952     }
36953     }
36954     }
36955     }
36956     }
36957     return false;
36958   }
36959 
36960   private boolean jj_3R_296() {
36961     if (jj_scan_token(TIME)) return true;
36962     if (jj_scan_token(ZONE)) return true;
36963     Token xsp;
36964     xsp = jj_scanpos;
36965     if (jj_3R_470()) {
36966     jj_scanpos = xsp;
36967     if (jj_3R_471()) {
36968     jj_scanpos = xsp;
36969     if (jj_3R_472()) {
36970     jj_scanpos = xsp;
36971     if (jj_3R_473()) return true;
36972     }
36973     }
36974     }
36975     return false;
36976   }
36977 
36978   private boolean jj_3R_469() {
36979     if (jj_3R_123()) return true;
36980     Token xsp;
36981     xsp = jj_scanpos;
36982     if (jj_3_25()) jj_scanpos = xsp;
36983     xsp = jj_scanpos;
36984     if (jj_scan_token(8)) {
36985     jj_scanpos = xsp;
36986     if (jj_3R_554()) return true;
36987     }
36988     xsp = jj_scanpos;
36989     if (jj_3R_555()) jj_scanpos = xsp;
36990     return false;
36991   }
36992 
36993   private boolean jj_3R_224() {
36994     if (jj_3R_297()) return true;
36995     return false;
36996   }
36997 
36998   private boolean jj_3R_295() {
36999     if (jj_scan_token(LOCAL)) return true;
37000     return false;
37001   }
37002 
37003   private boolean jj_3R_510() {
37004     if (jj_scan_token(3)) return true;
37005     if (jj_3R_123()) return true;
37006     return false;
37007   }
37008 
37009   private boolean jj_3R_330() {
37010     if (jj_3R_190()) return true;
37011     if (jj_scan_token(BEGIN)) return true;
37012     Token xsp;
37013     while (true) {
37014       xsp = jj_scanpos;
37015       if (jj_3R_456()) { jj_scanpos = xsp; break; }
37016     }
37017     xsp = jj_scanpos;
37018     if (jj_3R_457()) jj_scanpos = xsp;
37019     if (jj_scan_token(END)) return true;
37020     xsp = jj_scanpos;
37021     if (jj_3R_458()) jj_scanpos = xsp;
37022     return false;
37023   }
37024 
37025   private boolean jj_3_21() {
37026     if (jj_3R_122()) return true;
37027     return false;
37028   }
37029 
37030   private boolean jj_3_22() {
37031     if (jj_3R_123()) return true;
37032     if (jj_scan_token(3)) return true;
37033     return false;
37034   }
37035 
37036   private boolean jj_3R_153() {
37037     Token xsp;
37038     xsp = jj_scanpos;
37039     if (jj_3_22()) jj_scanpos = xsp;
37040     if (jj_3R_123()) return true;
37041     return false;
37042   }
37043 
37044   private boolean jj_3R_223() {
37045     if (jj_scan_token(AT)) return true;
37046     Token xsp;
37047     xsp = jj_scanpos;
37048     if (jj_3R_295()) {
37049     jj_scanpos = xsp;
37050     if (jj_3R_296()) return true;
37051     }
37052     return false;
37053   }
37054 
37055   private boolean jj_3R_386() {
37056     if (jj_scan_token(RELIES_ON)) return true;
37057     if (jj_scan_token(5)) return true;
37058     if (jj_3R_123()) return true;
37059     Token xsp;
37060     xsp = jj_scanpos;
37061     if (jj_3R_595()) jj_scanpos = xsp;
37062     while (true) {
37063       xsp = jj_scanpos;
37064       if (jj_3R_596()) { jj_scanpos = xsp; break; }
37065     }
37066     if (jj_scan_token(7)) return true;
37067     return false;
37068   }
37069 
37070   private boolean jj_3R_222() {
37071     if (jj_scan_token(2)) return true;
37072     if (jj_3R_119()) return true;
37073     return false;
37074   }
37075 
37076   private boolean jj_3R_383() {
37077     if (jj_3R_424()) return true;
37078     return false;
37079   }
37080 
37081   private boolean jj_3R_236() {
37082     if (jj_3R_281()) return true;
37083     return false;
37084   }
37085 
37086   private boolean jj_3R_426() {
37087     Token xsp;
37088     xsp = jj_scanpos;
37089     if (jj_scan_token(201)) {
37090     jj_scanpos = xsp;
37091     if (jj_scan_token(70)) return true;
37092     }
37093     xsp = jj_scanpos;
37094     if (jj_3R_511()) jj_scanpos = xsp;
37095     if (jj_scan_token(BY)) return true;
37096     if (jj_scan_token(5)) return true;
37097     if (jj_3R_123()) return true;
37098     while (true) {
37099       xsp = jj_scanpos;
37100       if (jj_3R_617()) { jj_scanpos = xsp; break; }
37101     }
37102     if (jj_scan_token(7)) return true;
37103     return false;
37104   }
37105 
37106   private boolean jj_3R_221() {
37107     if (jj_scan_token(3)) return true;
37108     if (jj_3R_119()) return true;
37109     return false;
37110   }
37111 
37112   private boolean jj_3R_280() {
37113     Token xsp;
37114     xsp = jj_scanpos;
37115     if (jj_scan_token(150)) {
37116     jj_scanpos = xsp;
37117     if (jj_scan_token(50)) return true;
37118     }
37119     xsp = jj_scanpos;
37120     if (jj_3_21()) {
37121     jj_scanpos = xsp;
37122     if (jj_3R_330()) return true;
37123     }
37124     return false;
37125   }
37126 
37127   private boolean jj_3R_134() {
37128     Token xsp;
37129     xsp = jj_scanpos;
37130     if (jj_3R_221()) {
37131     jj_scanpos = xsp;
37132     if (jj_3R_222()) {
37133     jj_scanpos = xsp;
37134     if (jj_3R_223()) {
37135     jj_scanpos = xsp;
37136     if (jj_3R_224()) return true;
37137     }
37138     }
37139     }
37140     return false;
37141   }
37142 
37143   private boolean jj_3R_425() {
37144     if (jj_scan_token(USING)) return true;
37145     if (jj_3R_123()) return true;
37146     Token xsp;
37147     xsp = jj_scanpos;
37148     if (jj_3R_510()) jj_scanpos = xsp;
37149     return false;
37150   }
37151 
37152   private boolean jj_3R_385() {
37153     Token xsp;
37154     xsp = jj_scanpos;
37155     if (jj_3R_425()) {
37156     jj_scanpos = xsp;
37157     if (jj_3R_426()) return true;
37158     }
37159     return false;
37160   }
37161 
37162   private boolean jj_3R_275() {
37163     Token xsp;
37164     xsp = jj_scanpos;
37165     if (jj_scan_token(99)) {
37166     jj_scanpos = xsp;
37167     if (jj_scan_token(180)) return true;
37168     }
37169     return false;
37170   }
37171 
37172   private boolean jj_3_55() {
37173     Token xsp;
37174     if (jj_scan_token(5)) return true;
37175     while (true) {
37176       xsp = jj_scanpos;
37177       if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
37178     }
37179     if (jj_scan_token(WITH)) return true;
37180     return false;
37181   }
37182 
37183   private boolean jj_3R_141() {
37184     Token xsp;
37185     xsp = jj_scanpos;
37186     if (jj_scan_token(417)) {
37187     jj_scanpos = xsp;
37188     if (jj_scan_token(425)) {
37189     jj_scanpos = xsp;
37190     if (jj_3R_236()) {
37191     jj_scanpos = xsp;
37192     if (jj_scan_token(59)) {
37193     jj_scanpos = xsp;
37194     if (jj_scan_token(169)) {
37195     jj_scanpos = xsp;
37196     if (jj_scan_token(198)) {
37197     jj_scanpos = xsp;
37198     if (jj_scan_token(219)) {
37199     jj_scanpos = xsp;
37200     if (jj_scan_token(224)) {
37201     jj_scanpos = xsp;
37202     if (jj_scan_token(35)) {
37203     jj_scanpos = xsp;
37204     if (jj_scan_token(305)) {
37205     jj_scanpos = xsp;
37206     if (jj_scan_token(255)) {
37207     jj_scanpos = xsp;
37208     if (jj_scan_token(256)) {
37209     jj_scanpos = xsp;
37210     if (jj_scan_token(257)) {
37211     jj_scanpos = xsp;
37212     if (jj_scan_token(266)) {
37213     jj_scanpos = xsp;
37214     if (jj_scan_token(281)) {
37215     jj_scanpos = xsp;
37216     if (jj_scan_token(159)) {
37217     jj_scanpos = xsp;
37218     if (jj_scan_token(300)) {
37219     jj_scanpos = xsp;
37220     if (jj_scan_token(49)) return true;
37221     }
37222     }
37223     }
37224     }
37225     }
37226     }
37227     }
37228     }
37229     }
37230     }
37231     }
37232     }
37233     }
37234     }
37235     }
37236     }
37237     }
37238     return false;
37239   }
37240 
37241   private boolean jj_3_54() {
37242     if (jj_scan_token(WITH)) return true;
37243     return false;
37244   }
37245 
37246   private boolean jj_3R_279() {
37247     if (jj_scan_token(AGGREGATE)) return true;
37248     if (jj_scan_token(USING)) return true;
37249     if (jj_3R_123()) return true;
37250     return false;
37251   }
37252 
37253   private boolean jj_3R_329() {
37254     if (jj_scan_token(RESULT_CACHE)) return true;
37255     Token xsp;
37256     xsp = jj_scanpos;
37257     if (jj_3R_386()) jj_scanpos = xsp;
37258     return false;
37259   }
37260 
37261   private boolean jj_3_53() {
37262     Token xsp;
37263     if (jj_scan_token(5)) return true;
37264     while (true) {
37265       xsp = jj_scanpos;
37266       if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
37267     }
37268     if (jj_scan_token(SELECT)) return true;
37269     return false;
37270   }
37271 
37272   private boolean jj_3_52() {
37273     if (jj_scan_token(SELECT)) return true;
37274     return false;
37275   }
37276 
37277   private boolean jj_3R_294() {
37278     if (jj_scan_token(6)) return true;
37279     if (jj_3R_232()) return true;
37280     return false;
37281   }
37282 
37283   private boolean jj_3R_328() {
37284     if (jj_scan_token(PIPELINED)) return true;
37285     Token xsp;
37286     xsp = jj_scanpos;
37287     if (jj_3R_385()) jj_scanpos = xsp;
37288     return false;
37289   }
37290 
37291   private boolean jj_3_51() {
37292     if (jj_3R_138()) return true;
37293     return false;
37294   }
37295 
37296   private boolean jj_3R_327() {
37297     if (jj_scan_token(PARALLEL_ENABLE)) return true;
37298     Token xsp;
37299     xsp = jj_scanpos;
37300     if (jj_3R_383()) jj_scanpos = xsp;
37301     xsp = jj_scanpos;
37302     if (jj_3R_384()) jj_scanpos = xsp;
37303     return false;
37304   }
37305 
37306   private boolean jj_3_50() {
37307     if (jj_3R_137()) return true;
37308     return false;
37309   }
37310 
37311   private boolean jj_3R_326() {
37312     if (jj_3R_237()) return true;
37313     return false;
37314   }
37315 
37316   private boolean jj_3R_220() {
37317     if (jj_scan_token(5)) return true;
37318     if (jj_3R_232()) return true;
37319     Token xsp;
37320     while (true) {
37321       xsp = jj_scanpos;
37322       if (jj_3R_294()) { jj_scanpos = xsp; break; }
37323     }
37324     if (jj_scan_token(7)) return true;
37325     return false;
37326   }
37327 
37328   private boolean jj_3_49() {
37329     if (jj_3R_136()) return true;
37330     return false;
37331   }
37332 
37333   private boolean jj_3_48() {
37334     if (jj_3R_135()) return true;
37335     return false;
37336   }
37337 
37338   private boolean jj_3R_219() {
37339     if (jj_scan_token(5)) return true;
37340     if (jj_3R_178()) return true;
37341     if (jj_scan_token(7)) return true;
37342     return false;
37343   }
37344 
37345   private boolean jj_3R_218() {
37346     if (jj_scan_token(WITH)) return true;
37347     if (jj_3R_178()) return true;
37348     return false;
37349   }
37350 
37351   private boolean jj_3R_278() {
37352     Token xsp;
37353     xsp = jj_scanpos;
37354     if (jj_3R_325()) {
37355     jj_scanpos = xsp;
37356     if (jj_scan_token(94)) {
37357     jj_scanpos = xsp;
37358     if (jj_3R_326()) {
37359     jj_scanpos = xsp;
37360     if (jj_3R_327()) {
37361     jj_scanpos = xsp;
37362     if (jj_3R_328()) {
37363     jj_scanpos = xsp;
37364     if (jj_3R_329()) return true;
37365     }
37366     }
37367     }
37368     }
37369     }
37370     return false;
37371   }
37372 
37373   private boolean jj_3R_325() {
37374     if (jj_scan_token(AUTHID)) return true;
37375     Token xsp;
37376     xsp = jj_scanpos;
37377     if (jj_scan_token(37)) {
37378     jj_scanpos = xsp;
37379     if (jj_scan_token(36)) return true;
37380     }
37381     return false;
37382   }
37383 
37384   private boolean jj_3R_217() {
37385     if (jj_scan_token(5)) return true;
37386     if (jj_3R_178()) return true;
37387     if (jj_scan_token(7)) return true;
37388     return false;
37389   }
37390 
37391   private boolean jj_3R_216() {
37392     if (jj_scan_token(SELECT)) return true;
37393     if (jj_3R_178()) return true;
37394     return false;
37395   }
37396 
37397   private boolean jj_3R_194() {
37398     Token xsp;
37399     while (true) {
37400       xsp = jj_scanpos;
37401       if (jj_3R_278()) { jj_scanpos = xsp; break; }
37402     }
37403     xsp = jj_scanpos;
37404     if (jj_3R_279()) jj_scanpos = xsp;
37405     xsp = jj_scanpos;
37406     if (jj_3R_280()) jj_scanpos = xsp;
37407     if (jj_scan_token(4)) return true;
37408     return false;
37409   }
37410 
37411   private boolean jj_3R_215() {
37412     if (jj_3R_293()) return true;
37413     return false;
37414   }
37415 
37416   private boolean jj_3R_274() {
37417     if (jj_scan_token(OR)) return true;
37418     if (jj_scan_token(REPLACE)) return true;
37419     return false;
37420   }
37421 
37422   private boolean jj_3R_214() {
37423     if (jj_3R_138()) return true;
37424     return false;
37425   }
37426 
37427   private boolean jj_3R_213() {
37428     if (jj_3R_137()) return true;
37429     return false;
37430   }
37431 
37432   private boolean jj_3R_212() {
37433     if (jj_3R_136()) return true;
37434     return false;
37435   }
37436 
37437   private boolean jj_3R_211() {
37438     if (jj_3R_135()) return true;
37439     return false;
37440   }
37441 
37442   private boolean jj_3R_210() {
37443     if (jj_3R_292()) return true;
37444     return false;
37445   }
37446 
37447   private boolean jj_3R_193() {
37448     if (jj_3R_247()) return true;
37449     return false;
37450   }
37451 
37452   private boolean jj_3R_133() {
37453     Token xsp;
37454     xsp = jj_scanpos;
37455     if (jj_3R_210()) {
37456     jj_scanpos = xsp;
37457     if (jj_3R_211()) {
37458     jj_scanpos = xsp;
37459     if (jj_3R_212()) {
37460     jj_scanpos = xsp;
37461     if (jj_3R_213()) {
37462     jj_scanpos = xsp;
37463     if (jj_3R_214()) {
37464     jj_scanpos = xsp;
37465     if (jj_3R_215()) {
37466     jj_scanpos = xsp;
37467     if (jj_3R_216()) {
37468     jj_scanpos = xsp;
37469     if (jj_3R_217()) {
37470     jj_scanpos = xsp;
37471     if (jj_3R_218()) {
37472     jj_scanpos = xsp;
37473     if (jj_3R_219()) {
37474     jj_scanpos = xsp;
37475     if (jj_3R_220()) return true;
37476     }
37477     }
37478     }
37479     }
37480     }
37481     }
37482     }
37483     }
37484     }
37485     }
37486     return false;
37487   }
37488 
37489   private boolean jj_3_47() {
37490     if (jj_3R_134()) return true;
37491     return false;
37492   }
37493 
37494   private boolean jj_3_46() {
37495     if (jj_scan_token(NEW)) return true;
37496     if (jj_3R_133()) return true;
37497     return false;
37498   }
37499 
37500   private boolean jj_3R_191() {
37501     if (jj_scan_token(CREATE)) return true;
37502     Token xsp;
37503     xsp = jj_scanpos;
37504     if (jj_3R_274()) jj_scanpos = xsp;
37505     xsp = jj_scanpos;
37506     if (jj_3R_275()) jj_scanpos = xsp;
37507     return false;
37508   }
37509 
37510   private boolean jj_3R_291() {
37511     if (jj_3R_133()) return true;
37512     return false;
37513   }
37514 
37515   private boolean jj_3R_117() {
37516     Token xsp;
37517     xsp = jj_scanpos;
37518     if (jj_3R_191()) jj_scanpos = xsp;
37519     if (jj_3R_192()) return true;
37520     xsp = jj_scanpos;
37521     if (jj_3R_193()) {
37522     jj_scanpos = xsp;
37523     if (jj_3R_194()) return true;
37524     }
37525     return false;
37526   }
37527 
37528   private boolean jj_3R_290() {
37529     if (jj_scan_token(NEW)) return true;
37530     if (jj_3R_133()) return true;
37531     return false;
37532   }
37533 
37534   private boolean jj_3R_209() {
37535     Token xsp;
37536     xsp = jj_scanpos;
37537     if (jj_3R_290()) {
37538     jj_scanpos = xsp;
37539     if (jj_3R_291()) return true;
37540     }
37541     while (true) {
37542       xsp = jj_scanpos;
37543       if (jj_3_47()) { jj_scanpos = xsp; break; }
37544     }
37545     return false;
37546   }
37547 
37548   private boolean jj_3R_529() {
37549     if (jj_scan_token(CC_ERROR)) return true;
37550     if (jj_3R_232()) return true;
37551     if (jj_scan_token(CC_END)) return true;
37552     return false;
37553   }
37554 
37555   private boolean jj_3R_208() {
37556     if (jj_scan_token(NEW_DOT)) return true;
37557     if (jj_3R_119()) return true;
37558     return false;
37559   }
37560 
37561   private boolean jj_3R_528() {
37562     if (jj_3R_321()) return true;
37563     return false;
37564   }
37565 
37566   private boolean jj_3R_500() {
37567     Token xsp;
37568     xsp = jj_scanpos;
37569     if (jj_3R_528()) {
37570     jj_scanpos = xsp;
37571     if (jj_3R_529()) return true;
37572     }
37573     return false;
37574   }
37575 
37576   private boolean jj_3R_132() {
37577     Token xsp;
37578     xsp = jj_scanpos;
37579     if (jj_3R_208()) {
37580     jj_scanpos = xsp;
37581     if (jj_3R_209()) return true;
37582     }
37583     return false;
37584   }
37585 
37586   private boolean jj_3R_468() {
37587     if (jj_scan_token(CC_ELSE)) return true;
37588     Token xsp;
37589     while (true) {
37590       xsp = jj_scanpos;
37591       if (jj_3R_500()) { jj_scanpos = xsp; break; }
37592     }
37593     return false;
37594   }
37595 
37596   private boolean jj_3R_527() {
37597     if (jj_scan_token(CC_ERROR)) return true;
37598     if (jj_3R_232()) return true;
37599     if (jj_scan_token(CC_END)) return true;
37600     return false;
37601   }
37602 
37603   private boolean jj_3R_526() {
37604     if (jj_3R_321()) return true;
37605     return false;
37606   }
37607 
37608   private boolean jj_3R_499() {
37609     Token xsp;
37610     xsp = jj_scanpos;
37611     if (jj_3R_526()) {
37612     jj_scanpos = xsp;
37613     if (jj_3R_527()) return true;
37614     }
37615     return false;
37616   }
37617 
37618   private boolean jj_3R_467() {
37619     if (jj_scan_token(CC_ELSIF)) return true;
37620     if (jj_3R_342()) return true;
37621     if (jj_scan_token(CC_THEN)) return true;
37622     Token xsp;
37623     while (true) {
37624       xsp = jj_scanpos;
37625       if (jj_3R_499()) { jj_scanpos = xsp; break; }
37626     }
37627     return false;
37628   }
37629 
37630   private boolean jj_3R_498() {
37631     if (jj_scan_token(CC_ERROR)) return true;
37632     if (jj_3R_232()) return true;
37633     if (jj_scan_token(CC_END)) return true;
37634     return false;
37635   }
37636 
37637   private boolean jj_3R_252() {
37638     if (jj_3R_123()) return true;
37639     return false;
37640   }
37641 
37642   private boolean jj_3R_497() {
37643     if (jj_3R_321()) return true;
37644     return false;
37645   }
37646 
37647   private boolean jj_3R_466() {
37648     Token xsp;
37649     xsp = jj_scanpos;
37650     if (jj_3R_497()) {
37651     jj_scanpos = xsp;
37652     if (jj_3R_498()) return true;
37653     }
37654     return false;
37655   }
37656 
37657   private boolean jj_3R_584() {
37658     if (jj_3R_132()) return true;
37659     return false;
37660   }
37661 
37662   private boolean jj_3R_583() {
37663     if (jj_scan_token(NOT)) return true;
37664     if (jj_3R_478()) return true;
37665     return false;
37666   }
37667 
37668   private boolean jj_3R_539() {
37669     Token xsp;
37670     xsp = jj_scanpos;
37671     if (jj_3R_583()) {
37672     jj_scanpos = xsp;
37673     if (jj_3R_584()) return true;
37674     }
37675     return false;
37676   }
37677 
37678   private boolean jj_3R_422() {
37679     if (jj_scan_token(CC_IF)) return true;
37680     if (jj_3R_342()) return true;
37681     if (jj_scan_token(CC_THEN)) return true;
37682     Token xsp;
37683     while (true) {
37684       xsp = jj_scanpos;
37685       if (jj_3R_466()) { jj_scanpos = xsp; break; }
37686     }
37687     while (true) {
37688       xsp = jj_scanpos;
37689       if (jj_3R_467()) { jj_scanpos = xsp; break; }
37690     }
37691     while (true) {
37692       xsp = jj_scanpos;
37693       if (jj_3R_468()) { jj_scanpos = xsp; break; }
37694     }
37695     if (jj_scan_token(CC_END)) return true;
37696     return false;
37697   }
37698 
37699   private boolean jj_3R_273() {
37700     if (jj_3R_321()) return true;
37701     return false;
37702   }
37703 
37704   private boolean jj_3R_508() {
37705     if (jj_3R_539()) return true;
37706     return false;
37707   }
37708 
37709   private boolean jj_3R_538() {
37710     if (jj_scan_token(17)) return true;
37711     return false;
37712   }
37713 
37714   private boolean jj_3R_537() {
37715     if (jj_scan_token(16)) return true;
37716     return false;
37717   }
37718 
37719   private boolean jj_3R_381() {
37720     if (jj_3R_422()) return true;
37721     return false;
37722   }
37723 
37724   private boolean jj_3R_190() {
37725     Token xsp;
37726     while (true) {
37727       xsp = jj_scanpos;
37728       if (jj_3R_273()) { jj_scanpos = xsp; break; }
37729     }
37730     return false;
37731   }
37732 
37733   private boolean jj_3R_507() {
37734     Token xsp;
37735     xsp = jj_scanpos;
37736     if (jj_3R_537()) {
37737     jj_scanpos = xsp;
37738     if (jj_3R_538()) return true;
37739     }
37740     if (jj_3R_478()) return true;
37741     return false;
37742   }
37743 
37744   private boolean jj_3R_380() {
37745     if (jj_3R_421()) return true;
37746     return false;
37747   }
37748 
37749   private boolean jj_3_18() {
37750     Token xsp;
37751     xsp = jj_scanpos;
37752     if (jj_scan_token(124)) {
37753     jj_scanpos = xsp;
37754     if (jj_scan_token(220)) return true;
37755     }
37756     if (jj_3R_119()) return true;
37757     return false;
37758   }
37759 
37760   private boolean jj_3_17() {
37761     Token xsp;
37762     xsp = jj_scanpos;
37763     if (jj_scan_token(281)) {
37764     jj_scanpos = xsp;
37765     if (jj_scan_token(261)) return true;
37766     }
37767     if (jj_3R_119()) return true;
37768     xsp = jj_scanpos;
37769     if (jj_scan_token(150)) {
37770     jj_scanpos = xsp;
37771     if (jj_scan_token(50)) return true;
37772     }
37773     return false;
37774   }
37775 
37776   private boolean jj_3R_478() {
37777     Token xsp;
37778     xsp = jj_scanpos;
37779     if (jj_3R_507()) {
37780     jj_scanpos = xsp;
37781     if (jj_3R_508()) return true;
37782     }
37783     return false;
37784   }
37785 
37786   private boolean jj_3R_379() {
37787     if (jj_3R_420()) return true;
37788     return false;
37789   }
37790 
37791   private boolean jj_3R_378() {
37792     if (jj_3R_419()) return true;
37793     return false;
37794   }
37795 
37796   private boolean jj_3_20() {
37797     if (jj_3R_121()) return true;
37798     return false;
37799   }
37800 
37801   private boolean jj_3R_305() {
37802     if (jj_3R_348()) return true;
37803     return false;
37804   }
37805 
37806   private boolean jj_3_19() {
37807     if (jj_3R_120()) return true;
37808     return false;
37809   }
37810 
37811   private boolean jj_3R_377() {
37812     if (jj_3R_117()) return true;
37813     return false;
37814   }
37815 
37816   private boolean jj_3R_603() {
37817     if (jj_scan_token(MOD)) return true;
37818     return false;
37819   }
37820 
37821   private boolean jj_3R_602() {
37822     if (jj_scan_token(1)) return true;
37823     return false;
37824   }
37825 
37826   private boolean jj_3R_376() {
37827     if (jj_3R_151()) return true;
37828     return false;
37829   }
37830 
37831   private boolean jj_3R_601() {
37832     if (jj_scan_token(20)) return true;
37833     return false;
37834   }
37835 
37836   private boolean jj_3R_600() {
37837     if (jj_scan_token(19)) return true;
37838     return false;
37839   }
37840 
37841   private boolean jj_3_16() {
37842     if (jj_3R_118()) return true;
37843     return false;
37844   }
37845 
37846   private boolean jj_3R_375() {
37847     if (jj_3R_418()) return true;
37848     return false;
37849   }
37850 
37851   private boolean jj_3R_564() {
37852     Token xsp;
37853     xsp = jj_scanpos;
37854     if (jj_3R_600()) {
37855     jj_scanpos = xsp;
37856     if (jj_3R_601()) {
37857     jj_scanpos = xsp;
37858     if (jj_3R_602()) {
37859     jj_scanpos = xsp;
37860     if (jj_3R_603()) return true;
37861     }
37862     }
37863     }
37864     if (jj_3R_478()) return true;
37865     return false;
37866   }
37867 
37868   private boolean jj_3_15() {
37869     if (jj_3R_117()) return true;
37870     return false;
37871   }
37872 
37873   private boolean jj_3R_250() {
37874     Token xsp;
37875     xsp = jj_scanpos;
37876     if (jj_scan_token(99)) {
37877     jj_scanpos = xsp;
37878     if (jj_scan_token(180)) return true;
37879     }
37880     return false;
37881   }
37882 
37883   private boolean jj_3R_304() {
37884     if (jj_3R_172()) return true;
37885     return false;
37886   }
37887 
37888   private boolean jj_3R_531() {
37889     if (jj_3R_478()) return true;
37890     Token xsp;
37891     while (true) {
37892       xsp = jj_scanpos;
37893       if (jj_3R_564()) { jj_scanpos = xsp; break; }
37894     }
37895     return false;
37896   }
37897 
37898   private boolean jj_3R_321() {
37899     Token xsp;
37900     xsp = jj_scanpos;
37901     if (jj_3R_375()) {
37902     jj_scanpos = xsp;
37903     if (jj_3_16()) {
37904     jj_scanpos = xsp;
37905     if (jj_3R_376()) {
37906     jj_scanpos = xsp;
37907     if (jj_3R_377()) {
37908     jj_scanpos = xsp;
37909     if (jj_3_19()) {
37910     jj_scanpos = xsp;
37911     if (jj_3_20()) {
37912     jj_scanpos = xsp;
37913     if (jj_3R_378()) {
37914     jj_scanpos = xsp;
37915     if (jj_3R_379()) {
37916     jj_scanpos = xsp;
37917     if (jj_3R_380()) {
37918     jj_scanpos = xsp;
37919     if (jj_3R_381()) return true;
37920     }
37921     }
37922     }
37923     }
37924     }
37925     }
37926     }
37927     }
37928     }
37929     return false;
37930   }
37931 
37932   private boolean jj_3R_251() {
37933     if (jj_scan_token(BEGIN)) return true;
37934     Token xsp;
37935     while (true) {
37936       xsp = jj_scanpos;
37937       if (jj_3R_304()) { jj_scanpos = xsp; break; }
37938     }
37939     xsp = jj_scanpos;
37940     if (jj_3R_305()) jj_scanpos = xsp;
37941     return false;
37942   }
37943 
37944   private boolean jj_3R_298() {
37945     if (jj_scan_token(18)) return true;
37946     if (jj_3R_132()) return true;
37947     return false;
37948   }
37949 
37950   private boolean jj_3R_249() {
37951     if (jj_scan_token(OR)) return true;
37952     if (jj_scan_token(REPLACE)) return true;
37953     return false;
37954   }
37955 
37956   private boolean jj_3R_159() {
37957     Token xsp;
37958     xsp = jj_scanpos;
37959     if (jj_scan_token(150)) {
37960     jj_scanpos = xsp;
37961     if (jj_scan_token(50)) return true;
37962     }
37963     if (jj_3R_190()) return true;
37964     xsp = jj_scanpos;
37965     if (jj_3R_251()) jj_scanpos = xsp;
37966     if (jj_scan_token(END)) return true;
37967     xsp = jj_scanpos;
37968     if (jj_3R_252()) jj_scanpos = xsp;
37969     if (jj_scan_token(4)) return true;
37970     return false;
37971   }
37972 
37973   private boolean jj_3R_228() {
37974     if (jj_3R_132()) return true;
37975     Token xsp;
37976     while (true) {
37977       xsp = jj_scanpos;
37978       if (jj_3R_298()) { jj_scanpos = xsp; break; }
37979     }
37980     return false;
37981   }
37982 
37983   private boolean jj_3R_158() {
37984     if (jj_3R_247()) return true;
37985     return false;
37986   }
37987 
37988   private boolean jj_3R_269() {
37989     if (jj_3R_189()) return true;
37990     return false;
37991   }
37992 
37993   private boolean jj_3R_567() {
37994     if (jj_scan_token(18)) return true;
37995     return false;
37996   }
37997 
37998   private boolean jj_3R_566() {
37999     if (jj_scan_token(17)) return true;
38000     return false;
38001   }
38002 
38003   private boolean jj_3R_157() {
38004     if (jj_scan_token(CREATE)) return true;
38005     Token xsp;
38006     xsp = jj_scanpos;
38007     if (jj_3R_249()) jj_scanpos = xsp;
38008     xsp = jj_scanpos;
38009     if (jj_3R_250()) jj_scanpos = xsp;
38010     return false;
38011   }
38012 
38013   private boolean jj_3R_565() {
38014     if (jj_scan_token(16)) return true;
38015     return false;
38016   }
38017 
38018   private boolean jj_3R_532() {
38019     Token xsp;
38020     xsp = jj_scanpos;
38021     if (jj_3R_565()) {
38022     jj_scanpos = xsp;
38023     if (jj_3R_566()) {
38024     jj_scanpos = xsp;
38025     if (jj_3R_567()) return true;
38026     }
38027     }
38028     if (jj_3R_531()) return true;
38029     return false;
38030   }
38031 
38032   private boolean jj_3R_244() {
38033     Token xsp;
38034     xsp = jj_scanpos;
38035     if (jj_scan_token(99)) {
38036     jj_scanpos = xsp;
38037     if (jj_scan_token(180)) return true;
38038     }
38039     return false;
38040   }
38041 
38042   private boolean jj_3R_248() {
38043     if (jj_3R_123()) return true;
38044     return false;
38045   }
38046 
38047   private boolean jj_3R_103() {
38048     Token xsp;
38049     xsp = jj_scanpos;
38050     if (jj_3R_157()) jj_scanpos = xsp;
38051     xsp = jj_scanpos;
38052     if (jj_scan_token(206)) {
38053     jj_scanpos = xsp;
38054     if (jj_scan_token(281)) return true;
38055     }
38056     if (jj_scan_token(BODY)) return true;
38057     if (jj_3R_153()) return true;
38058     xsp = jj_scanpos;
38059     if (jj_3R_158()) {
38060     jj_scanpos = xsp;
38061     if (jj_3R_159()) return true;
38062     }
38063     return false;
38064   }
38065 
38066   private boolean jj_3R_502() {
38067     if (jj_3R_531()) return true;
38068     Token xsp;
38069     while (true) {
38070       xsp = jj_scanpos;
38071       if (jj_3R_532()) { jj_scanpos = xsp; break; }
38072     }
38073     return false;
38074   }
38075 
38076   private boolean jj_3R_582() {
38077     if (jj_3R_181()) return true;
38078     return false;
38079   }
38080 
38081   private boolean jj_3R_581() {
38082     if (jj_scan_token(CHARACTER_LITERAL)) return true;
38083     return false;
38084   }
38085 
38086   private boolean jj_3R_536() {
38087     if (jj_scan_token(ESCAPE)) return true;
38088     Token xsp;
38089     xsp = jj_scanpos;
38090     if (jj_3R_581()) {
38091     jj_scanpos = xsp;
38092     if (jj_3R_582()) return true;
38093     }
38094     return false;
38095   }
38096 
38097   private boolean jj_3R_156() {
38098     Token xsp;
38099     xsp = jj_scanpos;
38100     if (jj_scan_token(150)) {
38101     jj_scanpos = xsp;
38102     if (jj_scan_token(50)) return true;
38103     }
38104     if (jj_3R_190()) return true;
38105     if (jj_scan_token(END)) return true;
38106     xsp = jj_scanpos;
38107     if (jj_3R_248()) jj_scanpos = xsp;
38108     if (jj_scan_token(4)) return true;
38109     return false;
38110   }
38111 
38112   private boolean jj_3R_609() {
38113     if (jj_scan_token(ALL)) return true;
38114     return false;
38115   }
38116 
38117   private boolean jj_3R_608() {
38118     if (jj_scan_token(DISTINCT)) return true;
38119     return false;
38120   }
38121 
38122   private boolean jj_3R_580() {
38123     Token xsp;
38124     xsp = jj_scanpos;
38125     if (jj_3R_608()) {
38126     jj_scanpos = xsp;
38127     if (jj_3R_609()) return true;
38128     }
38129     return false;
38130   }
38131 
38132   private boolean jj_3R_155() {
38133     if (jj_3R_247()) return true;
38134     return false;
38135   }
38136 
38137   private boolean jj_3R_243() {
38138     if (jj_scan_token(OR)) return true;
38139     if (jj_scan_token(REPLACE)) return true;
38140     return false;
38141   }
38142 
38143   private boolean jj_3R_579() {
38144     if (jj_scan_token(UNION)) return true;
38145     return false;
38146   }
38147 
38148   private boolean jj_3R_246() {
38149     if (jj_3R_237()) return true;
38150     return false;
38151   }
38152 
38153   private boolean jj_3R_578() {
38154     if (jj_scan_token(INTERSECT)) return true;
38155     return false;
38156   }
38157 
38158   private boolean jj_3R_577() {
38159     if (jj_scan_token(EXCEPT)) return true;
38160     return false;
38161   }
38162 
38163   private boolean jj_3R_154() {
38164     Token xsp;
38165     xsp = jj_scanpos;
38166     if (jj_3R_245()) {
38167     jj_scanpos = xsp;
38168     if (jj_3R_246()) return true;
38169     }
38170     return false;
38171   }
38172 
38173   private boolean jj_3R_245() {
38174     if (jj_scan_token(AUTHID)) return true;
38175     Token xsp;
38176     xsp = jj_scanpos;
38177     if (jj_scan_token(37)) {
38178     jj_scanpos = xsp;
38179     if (jj_scan_token(36)) return true;
38180     }
38181     return false;
38182   }
38183 
38184   private boolean jj_3R_607() {
38185     if (jj_scan_token(OF)) return true;
38186     return false;
38187   }
38188 
38189   private boolean jj_3R_152() {
38190     if (jj_scan_token(CREATE)) return true;
38191     Token xsp;
38192     xsp = jj_scanpos;
38193     if (jj_3R_243()) jj_scanpos = xsp;
38194     xsp = jj_scanpos;
38195     if (jj_3R_244()) jj_scanpos = xsp;
38196     return false;
38197   }
38198 
38199   private boolean jj_3R_535() {
38200     if (jj_scan_token(MULTISET)) return true;
38201     Token xsp;
38202     xsp = jj_scanpos;
38203     if (jj_3R_577()) {
38204     jj_scanpos = xsp;
38205     if (jj_3R_578()) {
38206     jj_scanpos = xsp;
38207     if (jj_3R_579()) return true;
38208     }
38209     }
38210     xsp = jj_scanpos;
38211     if (jj_3R_580()) jj_scanpos = xsp;
38212     return false;
38213   }
38214 
38215   private boolean jj_3R_606() {
38216     if (jj_scan_token(SUBMULTISET)) return true;
38217     return false;
38218   }
38219 
38220   private boolean jj_3R_605() {
38221     if (jj_scan_token(MEMBER)) return true;
38222     return false;
38223   }
38224 
38225   private boolean jj_3R_102() {
38226     Token xsp;
38227     xsp = jj_scanpos;
38228     if (jj_3R_152()) jj_scanpos = xsp;
38229     if (jj_scan_token(PACKAGE)) return true;
38230     if (jj_3R_153()) return true;
38231     while (true) {
38232       xsp = jj_scanpos;
38233       if (jj_3R_154()) { jj_scanpos = xsp; break; }
38234     }
38235     xsp = jj_scanpos;
38236     if (jj_3R_155()) {
38237     jj_scanpos = xsp;
38238     if (jj_3R_156()) return true;
38239     }
38240     return false;
38241   }
38242 
38243   private boolean jj_3R_116() {
38244     if (jj_scan_token(DECLARE)) return true;
38245     if (jj_3R_190()) return true;
38246     return false;
38247   }
38248 
38249   private boolean jj_3R_576() {
38250     Token xsp;
38251     xsp = jj_scanpos;
38252     if (jj_3R_605()) {
38253     jj_scanpos = xsp;
38254     if (jj_3R_606()) return true;
38255     }
38256     xsp = jj_scanpos;
38257     if (jj_3R_607()) jj_scanpos = xsp;
38258     return false;
38259   }
38260 
38261   private boolean jj_3R_575() {
38262     if (jj_scan_token(FROM)) return true;
38263     return false;
38264   }
38265 
38266   private boolean jj_3R_574() {
38267     if (jj_scan_token(LIKE)) return true;
38268     return false;
38269   }
38270 
38271   private boolean jj_3R_573() {
38272     if (jj_scan_token(BETWEEN)) return true;
38273     return false;
38274   }
38275 
38276   private boolean jj_3R_572() {
38277     if (jj_scan_token(IN)) return true;
38278     return false;
38279   }
38280 
38281   private boolean jj_3R_604() {
38282     if (jj_scan_token(15)) return true;
38283     return false;
38284   }
38285 
38286   private boolean jj_3R_571() {
38287     if (jj_scan_token(NOT)) return true;
38288     return false;
38289   }
38290 
38291   private boolean jj_3R_570() {
38292     if (jj_scan_token(10)) return true;
38293     return false;
38294   }
38295 
38296   private boolean jj_3R_569() {
38297     if (jj_scan_token(15)) return true;
38298     return false;
38299   }
38300 
38301   private boolean jj_3R_534() {
38302     Token xsp;
38303     xsp = jj_scanpos;
38304     if (jj_3R_571()) jj_scanpos = xsp;
38305     xsp = jj_scanpos;
38306     if (jj_3R_572()) {
38307     jj_scanpos = xsp;
38308     if (jj_3R_573()) {
38309     jj_scanpos = xsp;
38310     if (jj_3R_574()) {
38311     jj_scanpos = xsp;
38312     if (jj_3R_575()) {
38313     jj_scanpos = xsp;
38314     if (jj_3R_576()) return true;
38315     }
38316     }
38317     }
38318     }
38319     return false;
38320   }
38321 
38322   private boolean jj_3R_320() {
38323     if (jj_3R_348()) return true;
38324     return false;
38325   }
38326 
38327   private boolean jj_3R_319() {
38328     if (jj_3R_172()) return true;
38329     return false;
38330   }
38331 
38332   private boolean jj_3R_568() {
38333     if (jj_scan_token(14)) return true;
38334     Token xsp;
38335     xsp = jj_scanpos;
38336     if (jj_3R_604()) jj_scanpos = xsp;
38337     return false;
38338   }
38339 
38340   private boolean jj_3R_115() {
38341     if (jj_3R_189()) return true;
38342     return false;
38343   }
38344 
38345   private boolean jj_3_14() {
38346     Token xsp;
38347     while (true) {
38348       xsp = jj_scanpos;
38349       if (jj_3R_115()) { jj_scanpos = xsp; break; }
38350     }
38351     xsp = jj_scanpos;
38352     if (jj_3R_116()) jj_scanpos = xsp;
38353     if (jj_scan_token(BEGIN)) return true;
38354     return false;
38355   }
38356 
38357   private boolean jj_3R_318() {
38358     if (jj_scan_token(DECLARE)) return true;
38359     if (jj_3R_190()) return true;
38360     return false;
38361   }
38362 
38363   private boolean jj_3R_270() {
38364     Token xsp;
38365     xsp = jj_scanpos;
38366     if (jj_3R_318()) jj_scanpos = xsp;
38367     if (jj_scan_token(BEGIN)) return true;
38368     while (true) {
38369       xsp = jj_scanpos;
38370       if (jj_3R_319()) { jj_scanpos = xsp; break; }
38371     }
38372     xsp = jj_scanpos;
38373     if (jj_3R_320()) jj_scanpos = xsp;
38374     if (jj_scan_token(END)) return true;
38375     xsp = jj_scanpos;
38376     if (jj_scan_token(417)) jj_scanpos = xsp;
38377     return false;
38378   }
38379 
38380   private boolean jj_3R_533() {
38381     Token xsp;
38382     xsp = jj_scanpos;
38383     if (jj_3R_568()) {
38384     jj_scanpos = xsp;
38385     if (jj_3R_569()) return true;
38386     }
38387     xsp = jj_scanpos;
38388     if (jj_3R_570()) jj_scanpos = xsp;
38389     return false;
38390   }
38391 
38392   private boolean jj_3R_503() {
38393     Token xsp;
38394     xsp = jj_scanpos;
38395     if (jj_3R_533()) {
38396     jj_scanpos = xsp;
38397     if (jj_3R_534()) {
38398     jj_scanpos = xsp;
38399     if (jj_3R_535()) return true;
38400     }
38401     }
38402     if (jj_3R_502()) return true;
38403     xsp = jj_scanpos;
38404     if (jj_3R_536()) jj_scanpos = xsp;
38405     return false;
38406   }
38407 
38408   private boolean jj_3R_200() {
38409     if (jj_3R_281()) return true;
38410     return false;
38411   }
38412 
38413   private boolean jj_3R_184() {
38414     Token xsp;
38415     while (true) {
38416       xsp = jj_scanpos;
38417       if (jj_3R_269()) { jj_scanpos = xsp; break; }
38418     }
38419     if (jj_3R_270()) return true;
38420     if (jj_scan_token(4)) return true;
38421     return false;
38422   }
38423 
38424   private boolean jj_3R_476() {
38425     if (jj_3R_502()) return true;
38426     Token xsp;
38427     while (true) {
38428       xsp = jj_scanpos;
38429       if (jj_3R_503()) { jj_scanpos = xsp; break; }
38430     }
38431     return false;
38432   }
38433 
38434   private boolean jj_3R_112() {
38435     Token xsp;
38436     xsp = jj_scanpos;
38437     if (jj_3R_184()) {
38438     jj_scanpos = xsp;
38439     if (jj_3_15()) return true;
38440     }
38441     return false;
38442   }
38443 
38444   private boolean jj_3R_506() {
38445     if (jj_scan_token(IS)) return true;
38446     return false;
38447   }
38448 
38449   private boolean jj_3R_123() {
38450     Token xsp;
38451     xsp = jj_scanpos;
38452     if (jj_scan_token(417)) {
38453     jj_scanpos = xsp;
38454     if (jj_scan_token(425)) {
38455     jj_scanpos = xsp;
38456     if (jj_3R_200()) {
38457     jj_scanpos = xsp;
38458     if (jj_scan_token(35)) {
38459     jj_scanpos = xsp;
38460     if (jj_scan_token(38)) {
38461     jj_scanpos = xsp;
38462     if (jj_scan_token(39)) {
38463     jj_scanpos = xsp;
38464     if (jj_scan_token(40)) {
38465     jj_scanpos = xsp;
38466     if (jj_scan_token(41)) {
38467     jj_scanpos = xsp;
38468     if (jj_scan_token(45)) {
38469     jj_scanpos = xsp;
38470     if (jj_scan_token(46)) {
38471     jj_scanpos = xsp;
38472     if (jj_scan_token(47)) {
38473     jj_scanpos = xsp;
38474     if (jj_scan_token(48)) {
38475     jj_scanpos = xsp;
38476     if (jj_scan_token(49)) {
38477     jj_scanpos = xsp;
38478     if (jj_scan_token(50)) {
38479     jj_scanpos = xsp;
38480     if (jj_scan_token(51)) {
38481     jj_scanpos = xsp;
38482     if (jj_scan_token(55)) {
38483     jj_scanpos = xsp;
38484     if (jj_scan_token(57)) {
38485     jj_scanpos = xsp;
38486     if (jj_scan_token(58)) {
38487     jj_scanpos = xsp;
38488     if (jj_scan_token(59)) {
38489     jj_scanpos = xsp;
38490     if (jj_scan_token(60)) {
38491     jj_scanpos = xsp;
38492     if (jj_scan_token(62)) {
38493     jj_scanpos = xsp;
38494     if (jj_scan_token(65)) {
38495     jj_scanpos = xsp;
38496     if (jj_scan_token(66)) {
38497     jj_scanpos = xsp;
38498     if (jj_scan_token(67)) {
38499     jj_scanpos = xsp;
38500     if (jj_scan_token(68)) {
38501     jj_scanpos = xsp;
38502     if (jj_scan_token(70)) {
38503     jj_scanpos = xsp;
38504     if (jj_scan_token(76)) {
38505     jj_scanpos = xsp;
38506     if (jj_scan_token(77)) {
38507     jj_scanpos = xsp;
38508     if (jj_scan_token(78)) {
38509     jj_scanpos = xsp;
38510     if (jj_scan_token(82)) {
38511     jj_scanpos = xsp;
38512     if (jj_scan_token(84)) {
38513     jj_scanpos = xsp;
38514     if (jj_scan_token(87)) {
38515     jj_scanpos = xsp;
38516     if (jj_scan_token(89)) {
38517     jj_scanpos = xsp;
38518     if (jj_scan_token(90)) {
38519     jj_scanpos = xsp;
38520     if (jj_scan_token(91)) {
38521     jj_scanpos = xsp;
38522     if (jj_scan_token(92)) {
38523     jj_scanpos = xsp;
38524     if (jj_scan_token(93)) {
38525     jj_scanpos = xsp;
38526     if (jj_scan_token(96)) {
38527     jj_scanpos = xsp;
38528     if (jj_scan_token(97)) {
38529     jj_scanpos = xsp;
38530     if (jj_scan_token(98)) {
38531     jj_scanpos = xsp;
38532     if (jj_scan_token(101)) {
38533     jj_scanpos = xsp;
38534     if (jj_scan_token(102)) {
38535     jj_scanpos = xsp;
38536     if (jj_scan_token(107)) {
38537     jj_scanpos = xsp;
38538     if (jj_scan_token(109)) {
38539     jj_scanpos = xsp;
38540     if (jj_scan_token(110)) {
38541     jj_scanpos = xsp;
38542     if (jj_scan_token(111)) {
38543     jj_scanpos = xsp;
38544     if (jj_scan_token(117)) {
38545     jj_scanpos = xsp;
38546     if (jj_scan_token(119)) {
38547     jj_scanpos = xsp;
38548     if (jj_scan_token(120)) {
38549     jj_scanpos = xsp;
38550     if (jj_scan_token(121)) {
38551     jj_scanpos = xsp;
38552     if (jj_scan_token(123)) {
38553     jj_scanpos = xsp;
38554     if (jj_scan_token(126)) {
38555     jj_scanpos = xsp;
38556     if (jj_scan_token(127)) {
38557     jj_scanpos = xsp;
38558     if (jj_scan_token(130)) {
38559     jj_scanpos = xsp;
38560     if (jj_scan_token(134)) {
38561     jj_scanpos = xsp;
38562     if (jj_scan_token(136)) {
38563     jj_scanpos = xsp;
38564     if (jj_scan_token(137)) {
38565     jj_scanpos = xsp;
38566     if (jj_scan_token(142)) {
38567     jj_scanpos = xsp;
38568     if (jj_scan_token(144)) {
38569     jj_scanpos = xsp;
38570     if (jj_scan_token(145)) {
38571     jj_scanpos = xsp;
38572     if (jj_scan_token(146)) {
38573     jj_scanpos = xsp;
38574     if (jj_scan_token(148)) {
38575     jj_scanpos = xsp;
38576     if (jj_scan_token(150)) {
38577     jj_scanpos = xsp;
38578     if (jj_scan_token(154)) {
38579     jj_scanpos = xsp;
38580     if (jj_scan_token(156)) {
38581     jj_scanpos = xsp;
38582     if (jj_scan_token(157)) {
38583     jj_scanpos = xsp;
38584     if (jj_scan_token(158)) {
38585     jj_scanpos = xsp;
38586     if (jj_scan_token(159)) {
38587     jj_scanpos = xsp;
38588     if (jj_scan_token(165)) {
38589     jj_scanpos = xsp;
38590     if (jj_scan_token(169)) {
38591     jj_scanpos = xsp;
38592     if (jj_scan_token(170)) {
38593     jj_scanpos = xsp;
38594     if (jj_scan_token(173)) {
38595     jj_scanpos = xsp;
38596     if (jj_scan_token(176)) {
38597     jj_scanpos = xsp;
38598     if (jj_scan_token(179)) {
38599     jj_scanpos = xsp;
38600     if (jj_scan_token(181)) {
38601     jj_scanpos = xsp;
38602     if (jj_scan_token(182)) {
38603     jj_scanpos = xsp;
38604     if (jj_scan_token(183)) {
38605     jj_scanpos = xsp;
38606     if (jj_scan_token(185)) {
38607     jj_scanpos = xsp;
38608     if (jj_scan_token(190)) {
38609     jj_scanpos = xsp;
38610     if (jj_scan_token(192)) {
38611     jj_scanpos = xsp;
38612     if (jj_scan_token(193)) {
38613     jj_scanpos = xsp;
38614     if (jj_scan_token(195)) {
38615     jj_scanpos = xsp;
38616     if (jj_scan_token(186)) {
38617     jj_scanpos = xsp;
38618     if (jj_scan_token(187)) {
38619     jj_scanpos = xsp;
38620     if (jj_scan_token(188)) {
38621     jj_scanpos = xsp;
38622     if (jj_scan_token(189)) {
38623     jj_scanpos = xsp;
38624     if (jj_scan_token(198)) {
38625     jj_scanpos = xsp;
38626     if (jj_scan_token(199)) {
38627     jj_scanpos = xsp;
38628     if (jj_scan_token(200)) {
38629     jj_scanpos = xsp;
38630     if (jj_scan_token(201)) {
38631     jj_scanpos = xsp;
38632     if (jj_scan_token(204)) {
38633     jj_scanpos = xsp;
38634     if (jj_scan_token(209)) {
38635     jj_scanpos = xsp;
38636     if (jj_scan_token(212)) {
38637     jj_scanpos = xsp;
38638     if (jj_scan_token(213)) {
38639     jj_scanpos = xsp;
38640     if (jj_scan_token(214)) {
38641     jj_scanpos = xsp;
38642     if (jj_scan_token(217)) {
38643     jj_scanpos = xsp;
38644     if (jj_scan_token(219)) {
38645     jj_scanpos = xsp;
38646     if (jj_scan_token(218)) {
38647     jj_scanpos = xsp;
38648     if (jj_scan_token(221)) {
38649     jj_scanpos = xsp;
38650     if (jj_scan_token(222)) {
38651     jj_scanpos = xsp;
38652     if (jj_scan_token(224)) {
38653     jj_scanpos = xsp;
38654     if (jj_scan_token(243)) {
38655     jj_scanpos = xsp;
38656     if (jj_scan_token(247)) {
38657     jj_scanpos = xsp;
38658     if (jj_scan_token(249)) {
38659     jj_scanpos = xsp;
38660     if (jj_scan_token(252)) {
38661     jj_scanpos = xsp;
38662     if (jj_scan_token(253)) {
38663     jj_scanpos = xsp;
38664     if (jj_scan_token(255)) {
38665     jj_scanpos = xsp;
38666     if (jj_scan_token(256)) {
38667     jj_scanpos = xsp;
38668     if (jj_scan_token(257)) {
38669     jj_scanpos = xsp;
38670     if (jj_scan_token(258)) {
38671     jj_scanpos = xsp;
38672     if (jj_scan_token(260)) {
38673     jj_scanpos = xsp;
38674     if (jj_scan_token(264)) {
38675     jj_scanpos = xsp;
38676     if (jj_scan_token(265)) {
38677     jj_scanpos = xsp;
38678     if (jj_scan_token(266)) {
38679     jj_scanpos = xsp;
38680     if (jj_scan_token(268)) {
38681     jj_scanpos = xsp;
38682     if (jj_scan_token(270)) {
38683     jj_scanpos = xsp;
38684     if (jj_scan_token(277)) {
38685     jj_scanpos = xsp;
38686     if (jj_scan_token(279)) {
38687     jj_scanpos = xsp;
38688     if (jj_scan_token(281)) {
38689     jj_scanpos = xsp;
38690     if (jj_scan_token(282)) {
38691     jj_scanpos = xsp;
38692     if (jj_scan_token(294)) {
38693     jj_scanpos = xsp;
38694     if (jj_scan_token(295)) {
38695     jj_scanpos = xsp;
38696     if (jj_scan_token(296)) {
38697     jj_scanpos = xsp;
38698     if (jj_scan_token(300)) {
38699     jj_scanpos = xsp;
38700     if (jj_scan_token(302)) {
38701     jj_scanpos = xsp;
38702     if (jj_scan_token(305)) {
38703     jj_scanpos = xsp;
38704     if (jj_scan_token(315)) {
38705     jj_scanpos = xsp;
38706     if (jj_scan_token(289)) {
38707     jj_scanpos = xsp;
38708     if (jj_scan_token(429)) {
38709     jj_scanpos = xsp;
38710     if (jj_scan_token(426)) {
38711     jj_scanpos = xsp;
38712     if (jj_scan_token(427)) {
38713     jj_scanpos = xsp;
38714     if (jj_scan_token(428)) return true;
38715     }
38716     }
38717     }
38718     }
38719     }
38720     }
38721     }
38722     }
38723     }
38724     }
38725     }
38726     }
38727     }
38728     }
38729     }
38730     }
38731     }
38732     }
38733     }
38734     }
38735     }
38736     }
38737     }
38738     }
38739     }
38740     }
38741     }
38742     }
38743     }
38744     }
38745     }
38746     }
38747     }
38748     }
38749     }
38750     }
38751     }
38752     }
38753     }
38754     }
38755     }
38756     }
38757     }
38758     }
38759     }
38760     }
38761     }
38762     }
38763     }
38764     }
38765     }
38766     }
38767     }
38768     }
38769     }
38770     }
38771     }
38772     }
38773     }
38774     }
38775     }
38776     }
38777     }
38778     }
38779     }
38780     }
38781     }
38782     }
38783     }
38784     }
38785     }
38786     }
38787     }
38788     }
38789     }
38790     }
38791     }
38792     }
38793     }
38794     }
38795     }
38796     }
38797     }
38798     }
38799     }
38800     }
38801     }
38802     }
38803     }
38804     }
38805     }
38806     }
38807     }
38808     }
38809     }
38810     }
38811     }
38812     }
38813     }
38814     }
38815     }
38816     }
38817     }
38818     }
38819     }
38820     }
38821     }
38822     }
38823     }
38824     }
38825     }
38826     }
38827     }
38828     }
38829     }
38830     }
38831     }
38832     }
38833     }
38834     }
38835     }
38836     }
38837     }
38838     }
38839     }
38840     }
38841     }
38842     }
38843     }
38844     }
38845     }
38846     return false;
38847   }
38848 
38849   private boolean jj_3R_505() {
38850     if (jj_scan_token(13)) return true;
38851     if (jj_scan_token(10)) return true;
38852     return false;
38853   }
38854 
38855   private boolean jj_3R_504() {
38856     if (jj_scan_token(10)) return true;
38857     return false;
38858   }
38859 
38860   private boolean jj_3R_477() {
38861     Token xsp;
38862     xsp = jj_scanpos;
38863     if (jj_3R_504()) {
38864     jj_scanpos = xsp;
38865     if (jj_3R_505()) {
38866     jj_scanpos = xsp;
38867     if (jj_3R_506()) return true;
38868     }
38869     }
38870     if (jj_3R_476()) return true;
38871     return false;
38872   }
38873 
38874   private boolean jj_3R_432() {
38875     if (jj_3R_476()) return true;
38876     Token xsp;
38877     while (true) {
38878       xsp = jj_scanpos;
38879       if (jj_3R_477()) { jj_scanpos = xsp; break; }
38880     }
38881     return false;
38882   }
38883 
38884   private boolean jj_3R_433() {
38885     if (jj_scan_token(AND)) return true;
38886     if (jj_3R_432()) return true;
38887     return false;
38888   }
38889 
38890   private boolean jj_3R_391() {
38891     if (jj_3R_432()) return true;
38892     Token xsp;
38893     while (true) {
38894       xsp = jj_scanpos;
38895       if (jj_3R_433()) { jj_scanpos = xsp; break; }
38896     }
38897     return false;
38898   }
38899 
38900   private boolean jj_3R_187() {
38901     if (jj_scan_token(3)) return true;
38902     if (jj_scan_token(ATTACH)) return true;
38903     return false;
38904   }
38905 
38906   private boolean jj_3R_392() {
38907     if (jj_scan_token(OR)) return true;
38908     if (jj_3R_391()) return true;
38909     return false;
38910   }
38911 
38912   private boolean jj_3R_342() {
38913     if (jj_3R_391()) return true;
38914     Token xsp;
38915     while (true) {
38916       xsp = jj_scanpos;
38917       if (jj_3R_392()) { jj_scanpos = xsp; break; }
38918     }
38919     return false;
38920   }
38921 
38922   private boolean jj_3R_235() {
38923     if (jj_scan_token(3)) return true;
38924     if (jj_3R_232()) return true;
38925     return false;
38926   }
38927 
38928   private boolean jj_3R_233() {
38929     if (jj_scan_token(AT)) return true;
38930     if (jj_scan_token(TIME)) return true;
38931     if (jj_scan_token(ZONE)) return true;
38932     if (jj_3R_132()) return true;
38933     return false;
38934   }
38935 
38936   private boolean jj_3R_138() {
38937     Token xsp;
38938     xsp = jj_scanpos;
38939     if (jj_scan_token(387)) {
38940     jj_scanpos = xsp;
38941     if (jj_scan_token(388)) return true;
38942     }
38943     if (jj_scan_token(5)) return true;
38944     if (jj_3R_232()) return true;
38945     xsp = jj_scanpos;
38946     if (jj_3R_233()) jj_scanpos = xsp;
38947     if (jj_scan_token(AS)) return true;
38948     if (jj_3R_234()) return true;
38949     if (jj_scan_token(7)) return true;
38950     while (true) {
38951       xsp = jj_scanpos;
38952       if (jj_3R_235()) { jj_scanpos = xsp; break; }
38953     }
38954     return false;
38955   }
38956 
38957   private boolean jj_3R_114() {
38958     Token xsp;
38959     xsp = jj_scanpos;
38960     if (jj_scan_token(2)) {
38961     jj_scanpos = xsp;
38962     if (jj_scan_token(374)) {
38963     jj_scanpos = xsp;
38964     if (jj_scan_token(73)) {
38965     jj_scanpos = xsp;
38966     if (jj_scan_token(77)) {
38967     jj_scanpos = xsp;
38968     if (jj_scan_token(376)) {
38969     jj_scanpos = xsp;
38970     if (jj_scan_token(377)) {
38971     jj_scanpos = xsp;
38972     if (jj_scan_token(378)) {
38973     jj_scanpos = xsp;
38974     if (jj_scan_token(110)) {
38975     jj_scanpos = xsp;
38976     if (jj_scan_token(112)) {
38977     jj_scanpos = xsp;
38978     if (jj_scan_token(379)) {
38979     jj_scanpos = xsp;
38980     if (jj_scan_token(380)) {
38981     jj_scanpos = xsp;
38982     if (jj_scan_token(218)) {
38983     jj_scanpos = xsp;
38984     if (jj_scan_token(381)) {
38985     jj_scanpos = xsp;
38986     if (jj_scan_token(382)) {
38987     jj_scanpos = xsp;
38988     if (jj_scan_token(250)) {
38989     jj_scanpos = xsp;
38990     if (jj_scan_token(291)) {
38991     jj_scanpos = xsp;
38992     if (jj_scan_token(292)) {
38993     jj_scanpos = xsp;
38994     if (jj_scan_token(258)) {
38995     jj_scanpos = xsp;
38996     if (jj_scan_token(383)) {
38997     jj_scanpos = xsp;
38998     if (jj_scan_token(384)) {
38999     jj_scanpos = xsp;
39000     if (jj_scan_token(385)) {
39001     jj_scanpos = xsp;
39002     if (jj_scan_token(74)) {
39003     jj_scanpos = xsp;
39004     if (jj_scan_token(128)) {
39005     jj_scanpos = xsp;
39006     if (jj_scan_token(237)) {
39007     jj_scanpos = xsp;
39008     if (jj_scan_token(98)) {
39009     jj_scanpos = xsp;
39010     if (jj_scan_token(417)) {
39011     jj_scanpos = xsp;
39012     if (jj_3R_187()) return true;
39013     }
39014     }
39015     }
39016     }
39017     }
39018     }
39019     }
39020     }
39021     }
39022     }
39023     }
39024     }
39025     }
39026     }
39027     }
39028     }
39029     }
39030     }
39031     }
39032     }
39033     }
39034     }
39035     }
39036     }
39037     }
39038     }
39039     if (jj_3R_188()) return true;
39040     return false;
39041   }
39042 
39043   private boolean jj_3R_227() {
39044     if (jj_3R_228()) return true;
39045     return false;
39046   }
39047 
39048   private boolean jj_3R_226() {
39049     Token xsp;
39050     xsp = jj_scanpos;
39051     if (jj_scan_token(396)) {
39052     jj_scanpos = xsp;
39053     if (jj_scan_token(397)) {
39054     jj_scanpos = xsp;
39055     if (jj_scan_token(392)) return true;
39056     }
39057     }
39058     return false;
39059   }
39060 
39061   private boolean jj_3R_113() {
39062     if (jj_3R_185()) return true;
39063     if (jj_3R_186()) return true;
39064     return false;
39065   }
39066 
39067   private boolean jj_3_13() {
39068     if (jj_3R_114()) return true;
39069     return false;
39070   }
39071 
39072   private boolean jj_3R_136() {
39073     if (jj_scan_token(TRIM)) return true;
39074     if (jj_scan_token(5)) return true;
39075     Token xsp;
39076     xsp = jj_scanpos;
39077     if (jj_3R_226()) jj_scanpos = xsp;
39078     xsp = jj_scanpos;
39079     if (jj_3R_227()) jj_scanpos = xsp;
39080     if (jj_scan_token(FROM)) return true;
39081     if (jj_3R_228()) return true;
39082     if (jj_scan_token(7)) return true;
39083     return false;
39084   }
39085 
39086   private boolean jj_3_12() {
39087     if (jj_3R_113()) return true;
39088     return false;
39089   }
39090 
39091   private boolean jj_3_11() {
39092     if (jj_3R_112()) return true;
39093     return false;
39094   }
39095 
39096   private boolean jj_3_10() {
39097     if (jj_3R_111()) return true;
39098     return false;
39099   }
39100 
39101   private boolean jj_3_9() {
39102     if (jj_3R_110()) return true;
39103     return false;
39104   }
39105 
39106   private boolean jj_3_8() {
39107     if (jj_3R_109()) return true;
39108     return false;
39109   }
39110 
39111   private boolean jj_3_7() {
39112     if (jj_3R_108()) return true;
39113     return false;
39114   }
39115 
39116   private boolean jj_3_6() {
39117     if (jj_3R_107()) return true;
39118     return false;
39119   }
39120 
39121   private boolean jj_3_5() {
39122     if (jj_3R_106()) return true;
39123     return false;
39124   }
39125 
39126   private boolean jj_3_4() {
39127     if (jj_3R_105()) return true;
39128     return false;
39129   }
39130 
39131   private boolean jj_3_3() {
39132     if (jj_3R_104()) return true;
39133     return false;
39134   }
39135 
39136   private boolean jj_3_2() {
39137     if (jj_3R_103()) return true;
39138     return false;
39139   }
39140 
39141   private boolean jj_3_1() {
39142     if (jj_3R_102()) return true;
39143     return false;
39144   }
39145 
39146   private boolean jj_3R_231() {
39147     if (jj_scan_token(ELSE)) return true;
39148     if (jj_3R_232()) return true;
39149     return false;
39150   }
39151 
39152   private boolean jj_3R_230() {
39153     if (jj_scan_token(WHEN)) return true;
39154     if (jj_3R_232()) return true;
39155     if (jj_scan_token(THEN)) return true;
39156     if (jj_3R_232()) return true;
39157     return false;
39158   }
39159 
39160   private boolean jj_3R_229() {
39161     if (jj_3R_232()) return true;
39162     return false;
39163   }
39164 
39165   private boolean jj_3R_137() {
39166     if (jj_scan_token(CASE)) return true;
39167     Token xsp;
39168     xsp = jj_scanpos;
39169     if (jj_3R_229()) jj_scanpos = xsp;
39170     if (jj_3R_230()) return true;
39171     while (true) {
39172       xsp = jj_scanpos;
39173       if (jj_3R_230()) { jj_scanpos = xsp; break; }
39174     }
39175     xsp = jj_scanpos;
39176     if (jj_3R_231()) jj_scanpos = xsp;
39177     if (jj_scan_token(END)) return true;
39178     return false;
39179   }
39180 
39181   private boolean jj_3R_341() {
39182     if (jj_3R_132()) return true;
39183     if (jj_scan_token(9)) return true;
39184     if (jj_scan_token(10)) return true;
39185     if (jj_3R_232()) return true;
39186     return false;
39187   }
39188 
39189   private boolean jj_3R_394() {
39190     if (jj_scan_token(CC_ELSE)) return true;
39191     if (jj_3R_232()) return true;
39192     return false;
39193   }
39194 
39195   private boolean jj_3R_393() {
39196     if (jj_scan_token(CC_ELSIF)) return true;
39197     if (jj_3R_342()) return true;
39198     if (jj_scan_token(CC_THEN)) return true;
39199     if (jj_3R_232()) return true;
39200     return false;
39201   }
39202 
39203   private boolean jj_3R_343() {
39204     if (jj_scan_token(CC_IF)) return true;
39205     if (jj_3R_342()) return true;
39206     if (jj_scan_token(CC_THEN)) return true;
39207     if (jj_3R_232()) return true;
39208     Token xsp;
39209     while (true) {
39210       xsp = jj_scanpos;
39211       if (jj_3R_393()) { jj_scanpos = xsp; break; }
39212     }
39213     while (true) {
39214       xsp = jj_scanpos;
39215       if (jj_3R_394()) { jj_scanpos = xsp; break; }
39216     }
39217     if (jj_scan_token(CC_END)) return true;
39218     return false;
39219   }
39220 
39221   private boolean jj_3_45() {
39222     if (jj_3R_132()) return true;
39223     if (jj_scan_token(9)) return true;
39224     if (jj_scan_token(10)) return true;
39225     return false;
39226   }
39227 
39228   private boolean jj_3R_301() {
39229     if (jj_3R_343()) return true;
39230     return false;
39231   }
39232 
39233   private boolean jj_3R_300() {
39234     if (jj_3R_342()) return true;
39235     return false;
39236   }
39237 
39238   private boolean jj_3R_299() {
39239     if (jj_3R_341()) return true;
39240     return false;
39241   }
39242 
39243   private boolean jj_3R_232() {
39244     Token xsp;
39245     xsp = jj_scanpos;
39246     if (jj_3R_299()) {
39247     jj_scanpos = xsp;
39248     if (jj_3R_300()) {
39249     jj_scanpos = xsp;
39250     if (jj_3R_301()) return true;
39251     }
39252     }
39253     return false;
39254   }
39255 
39256   private boolean jj_3R_108() {
39257     if (jj_scan_token(ALTER)) return true;
39258     if (jj_scan_token(TRIGGER)) return true;
39259     if (jj_3R_178()) return true;
39260     if (jj_scan_token(4)) return true;
39261     return false;
39262   }
39263 
39264   private boolean jj_3R_317() {
39265     if (jj_3R_374()) return true;
39266     return false;
39267   }
39268 
39269   private boolean jj_3R_419() {
39270     if (jj_3R_197()) return true;
39271     return false;
39272   }
39273 
39274   private boolean jj_3R_121() {
39275     if (jj_3R_197()) return true;
39276     return false;
39277   }
39278 
39279   private boolean jj_3R_316() {
39280     if (jj_3R_185()) return true;
39281     return false;
39282   }
39283 
39284   private boolean jj_3R_266() {
39285     Token xsp;
39286     xsp = jj_scanpos;
39287     if (jj_3R_316()) {
39288     jj_scanpos = xsp;
39289     if (jj_3R_317()) return true;
39290     }
39291     return false;
39292   }
39293 
39294   private boolean jj_3R_496() {
39295     if (jj_scan_token(IS)) return true;
39296     Token xsp;
39297     while (true) {
39298       xsp = jj_scanpos;
39299       if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
39300     }
39301     if (jj_3R_400()) return true;
39302     return false;
39303   }
39304 
39305   private boolean jj_3R_495() {
39306     if (jj_scan_token(RETURN)) return true;
39307     if (jj_3R_234()) return true;
39308     return false;
39309   }
39310 
39311   private boolean jj_3R_494() {
39312     if (jj_3R_382()) return true;
39313     return false;
39314   }
39315 
39316   private boolean jj_3R_197() {
39317     if (jj_scan_token(CURSOR)) return true;
39318     if (jj_3R_123()) return true;
39319     Token xsp;
39320     xsp = jj_scanpos;
39321     if (jj_3R_494()) jj_scanpos = xsp;
39322     xsp = jj_scanpos;
39323     if (jj_3R_495()) jj_scanpos = xsp;
39324     xsp = jj_scanpos;
39325     if (jj_3R_496()) jj_scanpos = xsp;
39326     if (jj_scan_token(4)) return true;
39327     return false;
39328   }
39329 
39330   private boolean jj_3R_374() {
39331     Token xsp;
39332     xsp = jj_scanpos;
39333     if (jj_scan_token(358)) {
39334     jj_scanpos = xsp;
39335     if (jj_scan_token(357)) {
39336     jj_scanpos = xsp;
39337     if (jj_scan_token(352)) {
39338     jj_scanpos = xsp;
39339     if (jj_scan_token(351)) {
39340     jj_scanpos = xsp;
39341     if (jj_scan_token(356)) {
39342     jj_scanpos = xsp;
39343     if (jj_scan_token(361)) return true;
39344     }
39345     }
39346     }
39347     }
39348     }
39349     return false;
39350   }
39351 
39352   private boolean jj_3R_272() {
39353     if (jj_scan_token(DISASSOCIATE)) return true;
39354     if (jj_scan_token(STATISTICS)) return true;
39355     return false;
39356   }
39357 
39358   private boolean jj_3_83() {
39359     if (jj_3R_123()) return true;
39360     if (jj_scan_token(3)) return true;
39361     return false;
39362   }
39363 
39364   private boolean jj_3R_557() {
39365     if (jj_3R_181()) return true;
39366     return false;
39367   }
39368 
39369   private boolean jj_3R_622() {
39370     if (jj_3R_181()) return true;
39371     return false;
39372   }
39373 
39374   private boolean jj_3R_271() {
39375     if (jj_scan_token(ASSOCIATE)) return true;
39376     if (jj_scan_token(STATISTICS)) return true;
39377     return false;
39378   }
39379 
39380   private boolean jj_3R_185() {
39381     Token xsp;
39382     xsp = jj_scanpos;
39383     if (jj_scan_token(46)) {
39384     jj_scanpos = xsp;
39385     if (jj_scan_token(341)) {
39386     jj_scanpos = xsp;
39387     if (jj_3R_271()) {
39388     jj_scanpos = xsp;
39389     if (jj_scan_token(343)) {
39390     jj_scanpos = xsp;
39391     if (jj_scan_token(74)) {
39392     jj_scanpos = xsp;
39393     if (jj_scan_token(82)) {
39394     jj_scanpos = xsp;
39395     if (jj_3R_272()) {
39396     jj_scanpos = xsp;
39397     if (jj_scan_token(98)) {
39398     jj_scanpos = xsp;
39399     if (jj_scan_token(128)) {
39400     jj_scanpos = xsp;
39401     if (jj_scan_token(354)) {
39402     jj_scanpos = xsp;
39403     if (jj_scan_token(230)) {
39404     jj_scanpos = xsp;
39405     if (jj_scan_token(237)) {
39406     jj_scanpos = xsp;
39407     if (jj_scan_token(362)) {
39408     jj_scanpos = xsp;
39409     if (jj_scan_token(347)) return true;
39410     }
39411     }
39412     }
39413     }
39414     }
39415     }
39416     }
39417     }
39418     }
39419     }
39420     }
39421     }
39422     }
39423     return false;
39424   }
39425 
39426   private boolean jj_3R_556() {
39427     if (jj_3R_181()) return true;
39428     return false;
39429   }
39430 
39431   private boolean jj_3R_420() {
39432     if (jj_scan_token(IDENTIFIER)) return true;
39433     return false;
39434   }
39435 
39436   private boolean jj_3_78() {
39437     if (jj_3R_123()) return true;
39438     if (jj_scan_token(3)) return true;
39439     return false;
39440   }
39441 
39442   private boolean jj_3_82() {
39443     if (jj_3R_121()) return true;
39444     return false;
39445   }
39446 
39447   private boolean jj_3R_268() {
39448     if (jj_3R_266()) return true;
39449     return false;
39450   }
39451 
39452   private boolean jj_3_81() {
39453     if (jj_3R_120()) return true;
39454     return false;
39455   }
39456 
39457   /** Generated Token Manager. */
39458   public PLSQLParserTokenManager token_source;
39459   SimpleCharStream jj_input_stream;
39460   /** Current token. */
39461   public Token token;
39462   /** Next token. */
39463   public Token jj_nt;
39464   private Token jj_scanpos, jj_lastpos;
39465   private int jj_la;
39466   private int jj_gen;
39467   final private int[] jj_la1 = new int[447];
39468   static private int[] jj_la1_0;
39469   static private int[] jj_la1_1;
39470   static private int[] jj_la1_2;
39471   static private int[] jj_la1_3;
39472   static private int[] jj_la1_4;
39473   static private int[] jj_la1_5;
39474   static private int[] jj_la1_6;
39475   static private int[] jj_la1_7;
39476   static private int[] jj_la1_8;
39477   static private int[] jj_la1_9;
39478   static private int[] jj_la1_10;
39479   static private int[] jj_la1_11;
39480   static private int[] jj_la1_12;
39481   static private int[] jj_la1_13;
39482   static {
39483       jj_la1_init_0();
39484       jj_la1_init_1();
39485       jj_la1_init_2();
39486       jj_la1_init_3();
39487       jj_la1_init_4();
39488       jj_la1_init_5();
39489       jj_la1_init_6();
39490       jj_la1_init_7();
39491       jj_la1_init_8();
39492       jj_la1_init_9();
39493       jj_la1_init_10();
39494       jj_la1_init_11();
39495       jj_la1_init_12();
39496       jj_la1_init_13();
39497    }
39498    private static void jj_la1_init_0() {
39499       jj_la1_0 = new int[] {0x20000c,0x0,0x0,0x2,0xc,0x200000,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x8,0x0,0x8,0x0,0x0,0x40,0x0,0x0,0x8,0x40,0x8,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x100,0x200,0x200,0x0,0x20,0x0,0x20,0x0,0x40,0x0,0x0,0x0,0x200,0x200,0x4,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x230020,0x0,0x0,0x10,0x30020,0x230020,0x200000,0x30020,0x0,0x0,0x0,0x230020,0x230020,0x230020,0x230020,0x0,0x0,0x1000,0x230020,0x0,0x230020,0x0,0x230020,0x0,0x0,0x0,0x1000,0x30020,0x0,0x30020,0x0,0x0,0x0,0x0,0x0,0x30020,0x40,0x0,0x0,0x0,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x230020,0x0,0x230020,0x0,0x230020,0x0,0x20,0x20,0x0,0x0,0x0,0x40,0x40,0x0,0x20,0x0,0x0,0x0,0x40,0x20,0x0,0x0,0x0,0x200,0x200,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x20,0x0,0x20,0x0,0x30020,0x0,0x0,0x30020,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x20,0x0,0x0,0x8,0x0,0x0,0x2400,0x2400,0xc000,0x8000,0xc000,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000,0x0,0x0,0x70000,0x70000,0x40000,0x180002,0x180002,0x30000,0x30020,0x20,0x20,0x20,0x40,0x0,0x0,0x20,0x30020,0x0,0x2c,0x0,0x0,0x0,0x808,0x8,0x30020,0x40,0x800000,0x0,0x0,0x0,0x40,0x30000,0x30000,0x40,0x0,0x0,0x40,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x20,0x12,0x0,0x0,0x12,0x0,0x12,0x0,0x0,0x0,0x0,0x0,0x12,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x12,0x0,0x12,0x12,0x40,0x40,0x0,0x20,0x40,0x80,0x0,0x0,0x20,0x40,0x80,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x30000,0x30000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
39500    }
39501    private static void jj_la1_init_1() {
39502       jj_la1_1 = new int[] {0x1004000,0x0,0x0,0x0,0x0,0x0,0x0,0xa9721c38,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x30,0x400000,0x40000,0xfefffff8,0x40000,0x0,0x0,0x0,0x0,0x0,0x40000,0xa9721c38,0x0,0x1000000,0xfefffff8,0x40000,0x0,0x0,0xfefffff8,0xfefffff8,0xfefffff8,0x0,0xfefffff8,0xfefffff8,0x0,0xfefffff8,0xfefffff8,0x0,0x0,0x0,0x0,0x400000,0x30,0x0,0x0,0x0,0x0,0x0,0xfefffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x1000,0x40000,0xa9721c38,0x0,0xfefffff8,0xfffffff8,0x40000,0x441000,0x0,0x0,0xbc721c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfefffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa8721c38,0x0,0x0,0x0,0x0,0x0,0x80000000,0x0,0x0,0x14000000,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa9721c38,0xa9721c38,0x0,0x0,0x0,0xa9721c38,0xa9721c38,0x0,0xa8721c38,0x0,0x0,0x0,0xa9721c38,0xa9721c38,0xa9721c38,0xa9721c38,0x0,0x0,0x0,0xa9721c38,0x0,0xa9721c38,0x0,0xa9721c38,0x0,0x0,0x0,0x0,0xa8721c38,0x0,0xa8721c38,0xa8721c38,0x0,0xa8721c38,0x0,0xa8721c38,0xa8721c38,0x0,0x0,0x0,0x20000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa9721c38,0x0,0xa9721c38,0x0,0xa9721c38,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbc721c38,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa8721c38,0x0,0x0,0xa8721c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa8721c38,0x0,0x100000,0x0,0x0,0x8000,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x2000,0x2000,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa8721c38,0xa8721c38,0xa8721c38,0xa8721c38,0x0,0x0,0xa8721c38,0x0,0xa8721c38,0x0,0x100000,0x0,0x0,0x0,0x0,0x0,0xa8721c38,0x0,0x40000,0x0,0x0,0xfefffff8,0x0,0x0,0x0,0x0,0xa8721ff8,0x0,0x0,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa8721c38,0xa8721c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0xa9721c38,0x0,0xfefffff8,0xfffffff8,0x40000,0x0,0x0,0x0,0x0,0x0,0x30,0x400000,0x40000,0x40000,0x0,0x0,0x0,0x40000,0x0,0x40000,0x0,0xfefffff8,0xfefffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0x0,0x4000,0x0,0x0,0x800,0x0,0x800,0x0,0x0,0x0,0x200000,0x200000,0x0,0x0,0x0,0x200000,0x200000,0x800,0x30,0x400000,0x40000,0xfefffff8,0x0,0xfefffff8,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfefffff8,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0x0,0x0,0x0,0x4000,0x0,0xfefffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0xa9721c38,0x0,0x0,0xfefffff8,0x0,0x0,0xfefffff8,0x0,0x4000,0x0,0x4000,0xfefffff8,0x4000,0x0,0x4000,0x420de000,0xa0701c30,0xfefffff8,0xa8721c38,0xbcf21ff8,0x14420000,0x0,};
39503    }
39504    private static void jj_la1_init_2() {
39505       jj_la1_2 = new int[] {0x12042e00,0x10000800,0x10000800,0x0,0x2600,0x0,0x2000000,0x93eb8fa3,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0xbfffffff,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x93eb8fa3,0x0,0x0,0xbfffffff,0x0,0x0,0x248000,0xbfffffff,0xbfffffff,0xbfffffff,0x0,0xbfffffff,0xbfffffff,0x0,0xbfffffff,0xbfffffff,0x0,0x0,0x0,0x40000,0x40000000,0x0,0x0,0x0,0x0,0x0,0x40,0xbfffffff,0x0,0x40,0x40,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x93eb8fa3,0x0,0xbfffffff,0xbfffffff,0x0,0x40000000,0x0,0x0,0x85eb8fad,0x8000000,0x8000000,0x48000,0x0,0x0,0x0,0x0,0x0,0xbfffffff,0x0,0x0,0x8000000,0x8000000,0x0,0x0,0x0,0x0,0x816b8fa1,0x0,0x0,0x0,0x0,0x4,0x0,0x4,0x0,0x480000c,0x0,0x0,0x4,0x0,0x0,0x0,0x800000,0x0,0x1000000,0x1000000,0x0,0x1000000,0x0,0x0,0x0,0x93eb8fa3,0x93eb8fa3,0x0,0x10000800,0x0,0x83eb8fa3,0x93eb8fa3,0x0,0x81eb8fa3,0x0,0x0,0x0,0x93eb8fa3,0x93eb8fa3,0x93eb8fa3,0x93eb8fa3,0x0,0x0,0x0,0x93eb8fa3,0x0,0x93eb8fa3,0x0,0x93eb8fa3,0x0,0x0,0x0,0x0,0x81eb8fa3,0x0,0x81eb8fa3,0x816b8fa1,0x0,0x816b8fa1,0x0,0x816b8fa1,0x81eb8fa3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x93eb8fa3,0x0,0x93eb8fa3,0x0,0x93eb8fa3,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x85eb8fad,0x0,0x0,0x0,0x8000000,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x81eb8fa3,0x0,0x0,0x81eb8fa3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x81eb8fa3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x81eb8fa3,0x81eb8fa3,0x81eb8fa3,0x81eb8fa3,0x0,0x800000,0x816b8fa1,0x0,0x81eb8fa3,0x0,0x0,0x800000,0x0,0x0,0x0,0x0,0x81eb8fa3,0x0,0x0,0x0,0x0,0xbfffffff,0x0,0x0,0x0,0x0,0x816b8fa1,0x0,0x0,0x0,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x816b8fa1,0x816bafa1,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x40000000,0x0,0x0,0x0,0x0,0x0,0x93eb8fa3,0x0,0xbfffffff,0xbfffffff,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbfffffff,0xbfffffff,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x8000,0x0,0x0,0x0,0x8000,0x8000,0x0,0x0,0x0,0x0,0xbfffffff,0x0,0xbfffffff,0x0,0x0,0x0,0x0,0x20000,0x0,0x20000,0x0,0x0,0x1,0x1,0xbfffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x10000000,0x0,0x10040400,0x0,0x10000000,0x0,0x10040400,0x0,0xbfffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000000,0x80000000,0x0,0x2000000,0x0,0x0,0x93eb8fa3,0x0,0x0,0xbfffffff,0x0,0x240000,0xbfffffff,0x0,0x40400,0x0,0x40400,0xbfffffff,0x40400,0x0,0x40400,0x3c843054,0x816b8fa1,0xbfffffff,0x816b8fa1,0x95fbcfad,0x4900004,0x0,};
39506    }
39507    private static void jj_la1_init_3() {
39508       jj_la1_3 = new int[] {0x10014004,0x0,0x0,0x0,0x14004,0x0,0x0,0x777f5698,0x800,0x0,0x0,0x8,0x8,0x0,0x0,0x0,0x0,0x0,0xfffffeff,0x0,0x0,0x8,0x8,0x0,0x0,0x0,0x777f5698,0x800,0x0,0xfffffeff,0x0,0x0,0x10400000,0xfffffeff,0xfffffeff,0xfffffeff,0x0,0xfffffeff,0xfffffeff,0x0,0xfffffeff,0xfffffeff,0x0,0x8,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffffeff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x777f5698,0x800,0xfffffeff,0xfffffeff,0x0,0x0,0x0,0x0,0x34df1698,0x0,0x0,0x10400000,0x0,0x0,0x0,0x10000000,0x0,0xfffffeff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x345f1698,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x777f5698,0x777f5698,0x0,0x4000,0x0,0x777f5698,0x777f5698,0x0,0x345f1698,0x0,0x20,0x0,0x777f5698,0x777f5698,0x777f5698,0x777f5698,0x0,0x0,0x0,0x777f5698,0x0,0x777f5698,0x0,0x777f5698,0x40,0x20,0x0,0x0,0x345f1698,0x0,0x345f1698,0x345f1698,0x0,0x345f1698,0x0,0x345f1698,0x345f1698,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x777f5698,0x0,0x777f5698,0x0,0x777f5698,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x34df1698,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x345f1698,0x0,0x0,0x345f1698,0x0,0x20,0x0,0x200,0x0,0x0,0x0,0x345f1698,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x400,0x1,0x1,0x8000000,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x345f1698,0x345f1698,0x345f1698,0x345f1698,0x0,0x100000,0x345f1698,0x0,0x345f1698,0x0,0x0,0x100000,0x100000,0x0,0x0,0x0,0x345f1698,0x0,0x0,0x0,0x0,0xfffffeff,0x0,0x0,0x0,0x0,0x345f1698,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x10000000,0x0,0x10000000,0x10000000,0x20000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x345f1698,0x345f1698,0x0,0x0,0x0,0x0,0x0,0x400000,0x0,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x777f5698,0x800,0xfffffeff,0xfffffeff,0x0,0x0,0x8,0x8,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffffeff,0xfffffeff,0x0,0x400000,0x0,0x0,0x400000,0x0,0x400000,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x400010,0x400010,0x0,0x0,0x0,0x400000,0x400000,0x4,0x0,0x0,0x0,0xfffffeff,0x0,0xfffffeff,0x0,0x400000,0x0,0x400000,0x0,0x0,0x0,0x4000000,0x4001000,0x0,0x0,0xfffffeff,0x0,0x0,0x0,0x0,0x0,0x8,0x8,0x0,0x1000000,0x0,0x0,0x4,0x0,0x0,0x0,0x4,0x0,0xfffffeff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x80,0x0,0x0,0x0,0x0,0x777f5698,0x0,0x0,0xfffffeff,0x0,0x10000000,0xfffffeff,0x0,0x4,0x0,0x4,0xfffffeff,0x4,0x0,0x4,0x8980a025,0x345f1698,0xfffffeff,0x345f1698,0x36dfd6da,0x800000,0x0,};
39509    }
39510    private static void jj_la1_init_4() {
39511       jj_la1_4 = new int[] {0x20004001,0x20004000,0x20004000,0x0,0x1,0x0,0x0,0xaba8f4da,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0xfffff7de,0x400000,0x0,0x0,0x0,0x0,0x0,0x400000,0xaba8f4da,0x0,0x0,0xfffff7de,0x400000,0x0,0x8000,0xfffff7de,0xfffff7de,0xfffff7de,0x0,0xfffff7de,0xfffff7de,0x0,0xfffff7de,0xfffff7de,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffff7de,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0xaba8f4da,0x0,0xfffff7de,0xfffff7de,0x400000,0x400000,0x100,0x100,0xcba9b49a,0x0,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0xfffff7de,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8ba8b49a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x40010000,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x10,0x10,0x0,0x10,0x0,0x0,0x0,0xaba8f4da,0xaba8f4da,0x0,0x20004000,0x0,0x8ba8b4da,0xaba8f4da,0x0,0x8ba8b49a,0x0,0x0,0x0,0xaba8f4da,0xaba8f4da,0xaba8f4da,0xaba8f4da,0x0,0x0,0x0,0xaba8f4da,0x0,0xaba8f4da,0x0,0xaba8f4da,0x0,0x0,0x400,0x0,0x8ba8b49a,0x0,0x8ba8b49a,0x8ba8b49a,0x0,0x8ba8b49a,0x0,0x8ba8b49a,0x8ba8b49a,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x100000,0x0,0x100,0x100,0x0,0x0,0x100,0x100,0x0,0x0,0x0,0x0,0xaba8f4da,0x0,0xaba8f4da,0x0,0xaba8f4da,0x0,0x0,0x0,0x0,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0xcba9b49a,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x8ba8b49a,0x0,0x0,0x8ba8b49a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8ba8b49a,0x0,0x0,0x0,0x0,0x0,0x400000,0x400000,0x4000100,0x0,0x0,0x0,0x0,0x0,0x0,0x4000100,0x40000,0x0,0x0,0x4000100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8ba8b49a,0x8ba8b49a,0x8ba8b49a,0x8ba8b49a,0x0,0x80000,0x8ba8b49a,0x0,0x8ba8b49a,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x8ba8b49a,0x0,0x0,0x0,0x0,0xfffff7de,0x0,0x0,0x0,0x0,0x8baab49a,0x2,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8ba8b49a,0x8ba8b49a,0x0,0x0,0x1000,0x1000,0x0,0x8000,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x0,0xaba8f4da,0x0,0xfffff7de,0xfffff7de,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x400000,0x0,0x400000,0x0,0xfffff7de,0xfffff7de,0x0,0x8000,0x0,0x0,0x8000,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8008000,0x8008000,0x0,0x0,0x0,0x8000,0x8000,0x0,0x0,0x0,0x400000,0xfffff7de,0x0,0xfffff7de,0x0,0x8000,0x0,0x8000,0x800,0x0,0x800,0x0,0x0,0x200000,0x200000,0xfffff7de,0x0,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x4000,0x0,0x4001,0x0,0x4000,0x0,0x4001,0x0,0xfffff7de,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xaba8f4da,0x0,0x0,0xfffff7de,0x0,0x0,0xfffff7de,0x0,0x1,0x0,0x1,0xfffff7de,0x1,0x0,0x1,0x64554325,0xba8b49a,0xfffff7de,0x8ba8b49a,0xcbabb49a,0x40090010,0x0,};
39512    }
39513    private static void jj_la1_init_5() {
39514       jj_la1_5 = new int[] {0x8,0x8,0x8,0x0,0x0,0x0,0x0,0x81b2dbdf,0x0,0x0,0x0,0x100000,0x100000,0x0,0x0,0x0,0x0,0x0,0xfffb7fff,0x0,0x0,0x100000,0x100000,0x0,0x0,0x0,0x81b2dbdf,0x0,0x0,0xfffb7fff,0x0,0x0,0x200005,0xfffb7fff,0xfffb7fff,0xfffb7fff,0x0,0xfffb7fff,0xfffb7fff,0x0,0xfffb7fff,0xfffb7fff,0x0,0x100000,0x100000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffb7fff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x81b2dbdf,0x0,0xfffb7fff,0xfffb7fff,0x0,0x0,0x0,0x0,0xff127bdf,0x0,0x0,0x200005,0x0,0x0,0x0,0x0,0x0,0xfffb7fff,0x200000,0xa00000,0x0,0x0,0x0,0x0,0x0,0x0,0x81125bdf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7e003000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x840,0x840,0x0,0x840,0x0,0x0,0x0,0x81b2dbdf,0x81b2dbdf,0x0,0x8,0x0,0x81b2dbdf,0x81b2dbdf,0x0,0x81b2dbdf,0x0,0x0,0x0,0x81b2dbdf,0x81b2dbdf,0x81b2dbdf,0x81b2dbdf,0x0,0x0,0x0,0x81b2dbdf,0x0,0x81b2dbdf,0x0,0x81b2dbdf,0x0,0x0,0x0,0x0,0x81b2dbdf,0x0,0x81b2dbdf,0x81125bdf,0x0,0x81125bdf,0x0,0x81125bdf,0x81b2dbdf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x81b2dbdf,0x0,0x81b2dbdf,0x0,0x81b2dbdf,0x0,0x0,0x0,0x200000,0x0,0x7c000000,0x0,0x0,0x0,0x0,0x200000,0x0,0x0,0x0,0xff127bdf,0x0,0x200000,0xa00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x81b2dbdf,0x0,0x0,0x81b2dbdf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8192dbdf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200004,0x0,0x0,0x0,0x200000,0x4,0x0,0x4,0x0,0x0,0x0,0x200004,0x0,0x0,0x0,0x0,0x0,0x200,0x200,0x0,0x81b2dbdf,0x81b2dbdf,0x81925bdf,0x8192dbdf,0x0,0x800000,0x81125bdf,0x0,0x81b2dbdf,0x0,0x0,0x800000,0x0,0x0,0x0,0x0,0x81b2dbdf,0x0,0x0,0x0,0x0,0xfffb7fff,0x0,0x0,0x0,0x0,0x81125bdf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200000,0xa00000,0x0,0x20000,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x81125bdf,0x81125bdf,0x0,0x0,0x0,0x0,0x0,0x200000,0x200000,0x0,0x1,0x1,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x81b2dbdf,0x0,0xfffb7fff,0xfffb7fff,0x0,0x0,0x100000,0x100000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffb7fff,0xfffb7fff,0x0,0x200005,0x0,0x0,0xa00000,0x200000,0x800000,0x0,0x0,0x0,0x0,0x0,0x100,0x0,0x100,0x0,0x0,0x0,0x200005,0x200005,0x0,0x0,0x0,0x200005,0x200005,0x100,0x0,0x0,0x0,0xfffb7fff,0x0,0xfffb7fff,0x0,0xa00000,0x200000,0x800000,0x200000,0x200000,0x200000,0x0,0x0,0x0,0x0,0xfffb7fff,0x0,0x0,0x0,0x0,0x0,0x100000,0x100000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffb7fff,0x4000,0x4000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x81b2dbdf,0x0,0x0,0xfffb7fff,0x0,0x0,0xfffb7fff,0x0,0x0,0x0,0x0,0xfffb7fff,0x0,0x0,0x0,0x2e40420,0x811259df,0xfffb7fff,0x81125bdf,0xff1b7bdf,0x7e003880,0x0,};
39515    }
39516    private static void jj_la1_init_6() {
39517       jj_la1_6 = new int[] {0x14004000,0x0,0x0,0x0,0x4000000,0x0,0x0,0xd9056c74,0x0,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff737fff,0x0,0x100,0x0,0x0,0x0,0x4000,0x0,0xd9056c74,0x0,0x0,0xff737fff,0x0,0x800000,0x10002200,0xfff37fff,0xfff37fff,0xfff37fff,0x0,0xfff37fff,0xfff37fff,0x0,0xfff37fff,0xfff37fff,0x100,0x0,0x0,0x0,0x88000,0x0,0x0,0x0,0x0,0x0,0x200,0xff737fff,0x0,0x200,0x200,0x0,0x0,0x0,0x0,0x88000,0x0,0x0,0xd9056c74,0x0,0xff737fff,0xfff37fff,0x0,0x88000,0x1000,0x0,0x99716c74,0x0,0x0,0x10002200,0x0,0x0,0x0,0x10000000,0x0,0xff737fff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x99016c74,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x700000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0xd9056c74,0xd9056c74,0x0,0x0,0x0,0xd9056c74,0xd9056c74,0x0,0x99016c74,0x0,0x0,0x0,0xd9056c74,0xd9056c74,0xd9056c74,0xd9056c74,0x0,0x0,0x0,0xd9056c74,0x0,0xd9056c74,0x0,0xd9056c74,0x0,0x0,0x0,0x0,0x99016c74,0x0,0x99016c74,0x99016c74,0x0,0x99016c74,0x0,0x99016c74,0x99016c74,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x1000,0x1000,0x0,0x1000,0x1000,0x1000,0x0,0x0,0x0,0x0,0xd9056c74,0x0,0xd9056c74,0x0,0xd9056c74,0x0,0x80000000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x99716c74,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x99016c74,0x0,0x0,0x99016c74,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x99016c74,0x0,0x0,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x99016c74,0x99016c74,0x99016c74,0x99016c74,0x0,0x0,0x99016c74,0x0,0x99016c74,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x99016c74,0x0,0x0,0x0,0x0,0xff737fff,0x0,0x0,0x0,0x0,0x99016c74,0x80000000,0x0,0x80000000,0x200,0x0,0x200,0x10004000,0x10004000,0x0,0x10004000,0x10004000,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x100,0x20000000,0x0,0x100,0x0,0x0,0x20000000,0x99016c74,0x99016c74,0x0,0x0,0x40,0x40,0x0,0x2000,0x0,0x2000,0x200,0x200,0x0,0x0,0x8000,0x80000,0x0,0x0,0x0,0xd9056c74,0x0,0xff737fff,0xfff37fff,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfff37fff,0xfff37fff,0x0,0x2200,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2200,0x2200,0x0,0x0,0x0,0x2200,0x2200,0x0,0x0,0x0,0x0,0xff737fff,0x0,0xff737fff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff737fff,0x0,0x0,0x0,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0x0,0x0,0x0,0x0,0xff737fff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xd9056c74,0x0,0x0,0xfff37fff,0x800000,0x10000000,0xff737fff,0x0,0x0,0x100,0x0,0xff737fff,0x0,0x0,0x0,0x2202038a,0x91016c34,0xff737fff,0x99016c74,0xdff17c75,0x700001,0x0,};
39518    }
39519    private static void jj_la1_init_7() {
39520       jj_la1_7 = new int[] {0x4a06040,0xa04000,0xa04000,0x0,0x4002000,0x0,0x0,0xc5f7dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf7ffdd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc5f7dd7f,0x0,0x0,0xf7ffdd7f,0x0,0x0,0x0,0xf7ffdd7f,0xf7ffdd7f,0xf7ffdd7f,0x0,0xf7ffdd7f,0xf7ffdd7f,0x0,0xf7ffdd7f,0xf7ffdd7f,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0xf7ffdd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x200,0x0,0x0,0xc5f7dd7f,0x0,0xf7ffdd7f,0xf7ffdd7f,0x0,0x200,0x0,0x0,0xe577dd7f,0x0,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0xf7ffdd7f,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0xc577dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20001,0x2002000b,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x400000,0x0,0x400000,0x0,0x0,0x0,0xc5f7dd7f,0xc5f7dd7f,0x0,0x4a04000,0x0,0xc5f7dd7f,0xc5f7dd7f,0x0,0xc5f7dd7f,0x0,0x0,0x0,0xc5f7dd7f,0xc5f7dd7f,0xc5f7dd7f,0xc5f7dd7f,0x0,0x1000,0x0,0xc5f7dd7f,0x0,0xc5f7dd7f,0x0,0xc5f7dd7f,0x0,0x0,0x0,0x0,0xc5f7dd7f,0x100000,0xc5f7dd7f,0xc577dd7f,0x0,0xc577dd7f,0x0,0xc577dd7f,0xc5f7dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc00,0x0,0xc00,0xc5f7dd7f,0x0,0xc5f7dd7f,0x0,0xc5f7dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0xe577dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x0,0xc5f7dd7f,0x0,0x0,0xc5f7dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc5f7dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc5f7dd7f,0xc5f7dd7f,0xc5f7dd7f,0xc5f7dd7f,0x0,0x0,0xc577dd7f,0x0,0xc5f7dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc5f7dd7f,0x0,0x0,0x0,0x0,0xf7ffdd7f,0x0,0x0,0x0,0x0,0xc577dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc577dd7f,0xc577dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0xc5f7dd7f,0x0,0xf7ffdd7f,0xf7ffdd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf7ffdd7f,0xf7ffdd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf7ffdd7f,0x0,0xf7ffdd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf7ffdd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2040,0x0,0x0,0x0,0x2040,0x0,0xf7ffdd7f,0x0,0x0,0x0,0x0,0x1000,0x1000,0x1000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc5f7dd7f,0x0,0x0,0xf7ffdd7f,0x0,0x0,0xf7ffdd7f,0x0,0x2040,0x0,0x2040,0xf7ffdd7f,0x2040,0x0,0x2040,0x3c802081,0x4577dd7e,0xf7ffdd7f,0xc577dd7f,0x677fdd7f,0x244e800f,0x0,};
39521    }
39522    private static void jj_la1_init_8() {
39523       jj_la1_8 = new int[] {0x2800004,0x0,0x0,0x0,0x4,0x0,0x0,0x2b5faceb,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fffffff,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x2b5faceb,0x0,0x0,0x2fffffff,0x0,0x0,0x8,0x2fffffff,0x2fffffff,0x2fffffff,0x0,0x2fffffff,0x2fffffff,0x0,0x2fffffff,0x2fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x0,0x0,0x2fffffff,0x0,0x20000000,0x20000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2b5faceb,0x0,0x2fffffff,0x2fffffff,0x0,0x0,0x0,0x0,0x2b5faceb,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x2fffffff,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x2b5faceb,0x0,0x0,0x1000,0x0,0x0,0x0,0x0,0x0,0x800,0x18000,0x0,0x0,0x0,0x0,0x200000,0x10000,0x0,0x0,0x0,0x0,0x0,0x200000,0x200000,0x0,0x2b5faceb,0x2b5faceb,0x80000000,0x0,0x0,0x2b5faceb,0x2b5faceb,0x0,0x2b5faceb,0x80000000,0x0,0x0,0x2b5faceb,0x2b5faceb,0x2b5faceb,0x2b5faceb,0x0,0x0,0x0,0x2b5faceb,0x0,0x2b5faceb,0x0,0x2b5faceb,0x0,0x0,0x40000000,0x0,0x6b5faceb,0x0,0x2b5faceb,0x2b5faceb,0x80000000,0x2b5faceb,0x80000000,0x2b5faceb,0x2b5faceb,0x0,0x20000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x0,0x0,0x0,0x2b5faceb,0x0,0x2b5faceb,0x0,0x2b5faceb,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x0,0x0,0x0,0x2b5fbceb,0x2000020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2b5faceb,0x0,0x0,0x2b5faceb,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x2b5faceb,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2b5faceb,0x2b5faceb,0x2b5faceb,0x2b5faceb,0x0,0x1010000,0x2b5faceb,0x0,0x2b5faceb,0x8000,0x0,0x1010000,0x1000000,0x0,0x0,0x0,0x2b5faceb,0x0,0x0,0x0,0x20000000,0x2fffffff,0x0,0x0,0x0,0x0,0x2b5faceb,0x0,0x0,0x0,0x0,0x0,0x0,0x2800000,0x2800000,0x0,0x2800000,0x2800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2b5faceb,0x2b5faceb,0x20000000,0x0,0x1000,0x1000,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x2b5faceb,0x0,0x2fffffff,0x2fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x8000000,0x0,0x2fffffff,0x2fffffff,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x8,0x0,0x0,0x0,0x8,0x8,0x0,0x0,0x0,0x0,0x2fffffff,0x0,0x2fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0,0x2b5faceb,0x0,0x0,0x2fffffff,0x0,0x0,0x2fffffff,0x0,0x0,0x0,0x0,0x2fffffff,0x0,0x0,0x0,0x50a05204,0x295fa8e8,0x2fffffff,0x2b5faceb,0x2fdfaffb,0x1f9000,0x0,};
39524    }
39525    private static void jj_la1_init_9() {
39526       jj_la1_9 = new int[] {0x8000058,0x8000040,0x8000040,0x0,0x18,0x0,0x0,0xffffbe6e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffee,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffbe6e,0x0,0x0,0xffffffee,0x0,0x0,0x0,0xffffffee,0xffffffee,0xffffffee,0x0,0xffffffee,0xffffffee,0x0,0xffffffee,0xffffffee,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffee,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffbe6e,0x0,0xffffffee,0xffffffee,0x0,0x0,0x0,0x0,0xf7ffffac,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffee,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf7ffbe2c,0x0,0x0,0x180000,0x0,0x0,0x0,0x20000000,0x1878180,0x21e7f780,0x0,0x0,0x0,0x0,0x20000000,0x28000000,0x0,0x0,0x2000000,0x2000000,0x4000000,0x2000000,0x8000000,0x8000000,0x0,0xffffbe6e,0xffffbe6e,0x0,0x8000040,0x0,0xffffbe2e,0xffffbe6e,0x0,0xffffbe2c,0x0,0x0,0x0,0xffffbe6e,0xffffbe6e,0xffffbe6e,0xffffbe6e,0x0,0x0,0x0,0xffffbe6e,0x0,0xffffbe6e,0x0,0xffffbe6e,0x0,0x0,0x0,0x0,0xffffbe2c,0x0,0xffffbe2c,0xf7ffbe2c,0x0,0xf7ffbe2c,0x0,0xf7ffbe2c,0xffffbe2c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffbe6e,0x0,0xffffbe6e,0x0,0xffffbe6e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180000,0x0,0x0,0x0,0x0,0x0,0xf7ffffac,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0xffffbe2c,0x0,0x0,0xffffbe2c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffbe2c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffbe2c,0xffffbe2c,0xffffbe2c,0xffffbe2c,0x0,0x0,0xf7ffbe2c,0x0,0xffffbe2c,0x4000000,0x0,0x0,0x0,0x20,0x0,0x0,0xffffbe2c,0x0,0x0,0x0,0x0,0xffffffee,0x0,0x0,0x0,0x0,0xf7ffbe2c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf7ffbe2c,0xf7ffbe2c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffbe6e,0x0,0xffffffee,0xffffffee,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffee,0xffffffee,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffee,0x0,0xffffffee,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffee,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0000000,0x40,0x0,0x40,0x0,0x40,0x0,0x40,0x0,0xffffffee,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0000000,0x0,0xffffbe6e,0xc0000000,0x0,0xffffffee,0xc0000000,0x0,0xffffffee,0xc0000000,0x0,0x0,0x0,0xffffffee,0x0,0x0,0x0,0x80001c1,0xf7fdae2c,0xffffffee,0xf7ffbe2c,0xf7ffffae,0x3fefff80,0x0,};
39527    }
39528    private static void jj_la1_init_10() {
39529       jj_la1_10 = new int[] {0x18e00000,0x0,0x0,0x0,0x0,0x0,0x0,0xffe01098,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe01098,0x0,0x0,0xffe00018,0x0,0x0,0x80,0xffe00098,0xffe01098,0xffe01098,0x400,0xffe01098,0xffe01098,0x200,0xffe01098,0xffe01098,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe01098,0x0,0xffe00018,0xffe00098,0x0,0x0,0x0,0x0,0xffe00098,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xffe00018,0x400,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe01098,0xffe01098,0x0,0x0,0x0,0xffe01098,0xffe01098,0x0,0xffe00098,0x0,0x0,0x0,0xffe01098,0xffe01098,0xffe01098,0xffe01098,0x0,0x0,0x0,0xffe01098,0x0,0xffe01098,0x0,0xffe01098,0x0,0x0,0x0,0x0,0xffe00098,0x0,0xffe00098,0xffe00018,0x0,0xffe00018,0x0,0xffe00018,0xffe00098,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe01098,0x400,0xffe01098,0x200,0xffe01098,0x1080,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00098,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00098,0x400,0x200,0xffe00098,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00018,0xffe00018,0xffe00018,0xffe00018,0x0,0x0,0xffe00018,0x0,0xffe00098,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00098,0x0,0x0,0x0,0x0,0xffe00018,0x0,0x0,0x0,0x0,0xffe00018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00018,0xffe00018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe01098,0x0,0xffe00018,0xffe00098,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00018,0xffe00018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00018,0x0,0xffe00018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x98e00000,0x0,0x0,0x0,0x98e00000,0x2000000,0xffe00018,0x18,0x18,0x4,0x2,0x0,0x0,0x0,0x40000000,0x0,0x40000000,0x0,0x0,0x0,0x5000000,0x1,0x20000000,0xffe01098,0x1,0x20000000,0xffe00019,0x1,0x0,0xffe00018,0x0,0x98e00000,0x0,0x98e00000,0xffe00018,0x18e00000,0x80000000,0x98e00000,0x60,0xffe00018,0xffe00018,0xffe00018,0xffe00018,0x0,0x0,};
39530    }
39531    private static void jj_la1_init_11() {
39532       jj_la1_11 = new int[] {0xff400404,0x0,0x0,0x0,0xff400000,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x800000,0x0,0xffffffff,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0xffffffff,0x800,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x800800,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x13000,0x0,0x0,0x0,0x0,0x13000,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x675,0x0,0x0,0x0,0x675,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xffffffff,0x0,0x80,0xffffffff,0x0,0x0,0xffffffff,0x0,0x675,0x0,0x675,0xffffffff,0x404,0x271,0x675,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x800000,0x0,};
39533    }
39534    private static void jj_la1_init_12() {
39535       jj_la1_12 = new int[] {0x3,0x0,0x0,0x0,0x3,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x3f8ffff,0x3f8ffff,0x3f8ffff,0x0,0x3f8ffff,0x3f8ffff,0x0,0x3f8ffff,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x3f8ffff,0x3f8ffff,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x3f8ffff,0x0,0x0,0x0,0x3f8ffff,0x3f8ffff,0x0,0x3f8ffff,0x0,0x0,0x0,0x3f8ffff,0x3f8ffff,0x3f8ffff,0x3f8ffff,0x0,0x0,0x0,0x3f8ffff,0x0,0x3f8ffff,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x3f8ffff,0x3f8ffff,0x0,0x3f8ffff,0x0,0x3f8ffff,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x3f8ffff,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x3100,0x3100,0x3f8ffff,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0xc00,0x0,0x0,0x0,0x0,0x800,0x0,0x800,0x0,0x0,0x0,0xc00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x3f8ffff,0x3f8ffff,0x3f8ffff,0x0,0x0,0x3f8ffff,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x3f8ffff,0x0,0x0,0xc000,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x3f8ffff,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x3f8ffff,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x20000,0x20000,0x60000,0x10000,0x0,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x3f8ffff,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x3f8ffff,0x3f8ffff,0x3f8ffff,0x3f8ffff,0x0,0x0,};
39536    }
39537    private static void jj_la1_init_13() {
39538       jj_la1_13 = new int[] {0x2,0x0,0x0,0x0,0x2,0x0,0x0,0x2c6,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e02,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2c6,0x0,0x0,0x3e02,0x0,0x0,0x2,0x3e02,0x3e02,0x3e02,0x0,0x3e02,0x3e02,0x0,0x3e02,0x3e02,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e02,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2c6,0x0,0x3e02,0x3e02,0x0,0x0,0x0,0x0,0x202,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e02,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x202,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2c6,0x2c6,0x0,0x0,0x0,0x2c6,0x2c6,0x0,0x2c6,0x0,0x0,0x2,0x2c6,0x2c6,0x2c6,0x2c6,0x2,0x0,0x0,0x2c6,0x2,0x2c6,0x2,0x2c6,0x0,0x0,0x0,0x0,0x2c6,0x0,0x2c6,0x202,0x0,0x202,0x0,0x202,0x2c6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2c6,0x0,0x2c6,0x0,0x2c6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x202,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x282,0x282,0x0,0x282,0x0,0x0,0x0,0x0,0x0,0x2c6,0x0,0x0,0x2c6,0x0,0x0,0xc0,0x0,0x0,0x0,0x0,0x2c6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2c6,0x2c6,0x2c6,0x2c6,0x0,0xc4,0x202,0x0,0x2c6,0x0,0x0,0xc4,0x0,0x0,0x0,0x0,0x2c6,0x0,0x0,0x0,0x0,0x3e82,0x0,0x0,0x0,0x0,0x202,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x202,0x202,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2c6,0x0,0x3e02,0x3e02,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x282,0x282,0x0,0x0,0x0,0x0,0x0,0x3e02,0x3e02,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e02,0x0,0x3e02,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e82,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e02,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2c6,0x0,0x0,0x3e02,0x0,0x2,0x3e02,0x0,0x0,0x0,0x0,0x3e02,0x0,0x0,0x0,0x0,0x0,0x3e02,0x202,0x202,0x3c00,0x1c00,};
39539    }
39540   final private JJCalls[] jj_2_rtns = new JJCalls[83];
39541   private boolean jj_rescan = false;
39542   private int jj_gc = 0;
39543 
39544   /** Constructor with InputStream. */
39545   public PLSQLParser(java.io.InputStream stream) {
39546      this(stream, null);
39547   }
39548   /** Constructor with InputStream and supplied encoding */
39549   public PLSQLParser(java.io.InputStream stream, String encoding) {
39550     try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
39551     token_source = new PLSQLParserTokenManager(jj_input_stream);
39552     token = new Token();
39553     token.next = jj_nt = token_source.getNextToken();
39554     jj_gen = 0;
39555     for (int i = 0; i < 447; i++) jj_la1[i] = -1;
39556     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
39557   }
39558 
39559   /** Reinitialise. */
39560   public void ReInit(java.io.InputStream stream) {
39561      ReInit(stream, null);
39562   }
39563   /** Reinitialise. */
39564   public void ReInit(java.io.InputStream stream, String encoding) {
39565     try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
39566     token_source.ReInit(jj_input_stream);
39567     token = new Token();
39568     token.next = jj_nt = token_source.getNextToken();
39569     jjtree.reset();
39570     jj_gen = 0;
39571     for (int i = 0; i < 447; i++) jj_la1[i] = -1;
39572     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
39573   }
39574 
39575   /** Constructor. */
39576   public PLSQLParser(java.io.Reader stream) {
39577     jj_input_stream = new SimpleCharStream(stream, 1, 1);
39578     token_source = new PLSQLParserTokenManager(jj_input_stream);
39579     token = new Token();
39580     token.next = jj_nt = token_source.getNextToken();
39581     jj_gen = 0;
39582     for (int i = 0; i < 447; i++) jj_la1[i] = -1;
39583     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
39584   }
39585 
39586   /** Reinitialise. */
39587   public void ReInit(java.io.Reader stream) {
39588     jj_input_stream.ReInit(stream, 1, 1);
39589     token_source.ReInit(jj_input_stream);
39590     token = new Token();
39591     token.next = jj_nt = token_source.getNextToken();
39592     jjtree.reset();
39593     jj_gen = 0;
39594     for (int i = 0; i < 447; i++) jj_la1[i] = -1;
39595     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
39596   }
39597 
39598   /** Constructor with generated Token Manager. */
39599   public PLSQLParser(PLSQLParserTokenManager tm) {
39600     token_source = tm;
39601     token = new Token();
39602     token.next = jj_nt = token_source.getNextToken();
39603     jj_gen = 0;
39604     for (int i = 0; i < 447; i++) jj_la1[i] = -1;
39605     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
39606   }
39607 
39608   /** Reinitialise. */
39609   public void ReInit(PLSQLParserTokenManager tm) {
39610     token_source = tm;
39611     token = new Token();
39612     token.next = jj_nt = token_source.getNextToken();
39613     jjtree.reset();
39614     jj_gen = 0;
39615     for (int i = 0; i < 447; i++) jj_la1[i] = -1;
39616     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
39617   }
39618 
39619   private Token jj_consume_token(int kind) throws ParseException {
39620     Token oldToken = token;
39621     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
39622     else jj_nt = jj_nt.next = token_source.getNextToken();
39623     if (token.kind == kind) {
39624       jj_gen++;
39625       if (++jj_gc > 100) {
39626         jj_gc = 0;
39627         for (int i = 0; i < jj_2_rtns.length; i++) {
39628           JJCalls c = jj_2_rtns[i];
39629           while (c != null) {
39630             if (c.gen < jj_gen) c.first = null;
39631             c = c.next;
39632           }
39633         }
39634       }
39635       return token;
39636     }
39637     jj_nt = token;
39638     token = oldToken;
39639     jj_kind = kind;
39640     throw generateParseException();
39641   }
39642 
39643   static private final class LookaheadSuccess extends java.lang.Error { }
39644   final private LookaheadSuccess jj_ls = new LookaheadSuccess();
39645   private boolean jj_scan_token(int kind) {
39646     if (jj_scanpos == jj_lastpos) {
39647       jj_la--;
39648       if (jj_scanpos.next == null) {
39649         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
39650       } else {
39651         jj_lastpos = jj_scanpos = jj_scanpos.next;
39652       }
39653     } else {
39654       jj_scanpos = jj_scanpos.next;
39655     }
39656     if (jj_rescan) {
39657       int i = 0; Token tok = token;
39658       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
39659       if (tok != null) jj_add_error_token(kind, i);
39660     }
39661     if (jj_scanpos.kind != kind) return true;
39662     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
39663     return false;
39664   }
39665 
39666 
39667 /** Get the next Token. */
39668   final public Token getNextToken() {
39669     if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
39670     else jj_nt = jj_nt.next = token_source.getNextToken();
39671     jj_gen++;
39672     return token;
39673   }
39674 
39675 /** Get the specific Token. */
39676   final public Token getToken(int index) {
39677     Token t = token;
39678     for (int i = 0; i < index; i++) {
39679       if (t.next != null) t = t.next;
39680       else t = t.next = token_source.getNextToken();
39681     }
39682     return t;
39683   }
39684 
39685   private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
39686   private int[] jj_expentry;
39687   private int jj_kind = -1;
39688   private int[] jj_lasttokens = new int[100];
39689   private int jj_endpos;
39690 
39691   private void jj_add_error_token(int kind, int pos) {
39692     if (pos >= 100) return;
39693     if (pos == jj_endpos + 1) {
39694       jj_lasttokens[jj_endpos++] = kind;
39695     } else if (jj_endpos != 0) {
39696       jj_expentry = new int[jj_endpos];
39697       for (int i = 0; i < jj_endpos; i++) {
39698         jj_expentry[i] = jj_lasttokens[i];
39699       }
39700       jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
39701         int[] oldentry = (int[])(it.next());
39702         if (oldentry.length == jj_expentry.length) {
39703           for (int i = 0; i < jj_expentry.length; i++) {
39704             if (oldentry[i] != jj_expentry[i]) {
39705               continue jj_entries_loop;
39706             }
39707           }
39708           jj_expentries.add(jj_expentry);
39709           break jj_entries_loop;
39710         }
39711       }
39712       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
39713     }
39714   }
39715 
39716   /** Generate ParseException. */
39717   public ParseException generateParseException() {
39718     jj_expentries.clear();
39719     boolean[] la1tokens = new boolean[431];
39720     if (jj_kind >= 0) {
39721       la1tokens[jj_kind] = true;
39722       jj_kind = -1;
39723     }
39724     for (int i = 0; i < 447; i++) {
39725       if (jj_la1[i] == jj_gen) {
39726         for (int j = 0; j < 32; j++) {
39727           if ((jj_la1_0[i] & (1<<j)) != 0) {
39728             la1tokens[j] = true;
39729           }
39730           if ((jj_la1_1[i] & (1<<j)) != 0) {
39731             la1tokens[32+j] = true;
39732           }
39733           if ((jj_la1_2[i] & (1<<j)) != 0) {
39734             la1tokens[64+j] = true;
39735           }
39736           if ((jj_la1_3[i] & (1<<j)) != 0) {
39737             la1tokens[96+j] = true;
39738           }
39739           if ((jj_la1_4[i] & (1<<j)) != 0) {
39740             la1tokens[128+j] = true;
39741           }
39742           if ((jj_la1_5[i] & (1<<j)) != 0) {
39743             la1tokens[160+j] = true;
39744           }
39745           if ((jj_la1_6[i] & (1<<j)) != 0) {
39746             la1tokens[192+j] = true;
39747           }
39748           if ((jj_la1_7[i] & (1<<j)) != 0) {
39749             la1tokens[224+j] = true;
39750           }
39751           if ((jj_la1_8[i] & (1<<j)) != 0) {
39752             la1tokens[256+j] = true;
39753           }
39754           if ((jj_la1_9[i] & (1<<j)) != 0) {
39755             la1tokens[288+j] = true;
39756           }
39757           if ((jj_la1_10[i] & (1<<j)) != 0) {
39758             la1tokens[320+j] = true;
39759           }
39760           if ((jj_la1_11[i] & (1<<j)) != 0) {
39761             la1tokens[352+j] = true;
39762           }
39763           if ((jj_la1_12[i] & (1<<j)) != 0) {
39764             la1tokens[384+j] = true;
39765           }
39766           if ((jj_la1_13[i] & (1<<j)) != 0) {
39767             la1tokens[416+j] = true;
39768           }
39769         }
39770       }
39771     }
39772     for (int i = 0; i < 431; i++) {
39773       if (la1tokens[i]) {
39774         jj_expentry = new int[1];
39775         jj_expentry[0] = i;
39776         jj_expentries.add(jj_expentry);
39777       }
39778     }
39779     jj_endpos = 0;
39780     jj_rescan_token();
39781     jj_add_error_token(0, 0);
39782     int[][] exptokseq = new int[jj_expentries.size()][];
39783     for (int i = 0; i < jj_expentries.size(); i++) {
39784       exptokseq[i] = jj_expentries.get(i);
39785     }
39786     return new ParseException(token, exptokseq, tokenImage);
39787   }
39788 
39789   /** Enable tracing. */
39790   final public void enable_tracing() {
39791   }
39792 
39793   /** Disable tracing. */
39794   final public void disable_tracing() {
39795   }
39796 
39797   private void jj_rescan_token() {
39798     jj_rescan = true;
39799     for (int i = 0; i < 83; i++) {
39800     try {
39801       JJCalls p = jj_2_rtns[i];
39802       do {
39803         if (p.gen > jj_gen) {
39804           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
39805           switch (i) {
39806             case 0: jj_3_1(); break;
39807             case 1: jj_3_2(); break;
39808             case 2: jj_3_3(); break;
39809             case 3: jj_3_4(); break;
39810             case 4: jj_3_5(); break;
39811             case 5: jj_3_6(); break;
39812             case 6: jj_3_7(); break;
39813             case 7: jj_3_8(); break;
39814             case 8: jj_3_9(); break;
39815             case 9: jj_3_10(); break;
39816             case 10: jj_3_11(); break;
39817             case 11: jj_3_12(); break;
39818             case 12: jj_3_13(); break;
39819             case 13: jj_3_14(); break;
39820             case 14: jj_3_15(); break;
39821             case 15: jj_3_16(); break;
39822             case 16: jj_3_17(); break;
39823             case 17: jj_3_18(); break;
39824             case 18: jj_3_19(); break;
39825             case 19: jj_3_20(); break;
39826             case 20: jj_3_21(); break;
39827             case 21: jj_3_22(); break;
39828             case 22: jj_3_23(); break;
39829             case 23: jj_3_24(); break;
39830             case 24: jj_3_25(); break;
39831             case 25: jj_3_26(); break;
39832             case 26: jj_3_27(); break;
39833             case 27: jj_3_28(); break;
39834             case 28: jj_3_29(); break;
39835             case 29: jj_3_30(); break;
39836             case 30: jj_3_31(); break;
39837             case 31: jj_3_32(); break;
39838             case 32: jj_3_33(); break;
39839             case 33: jj_3_34(); break;
39840             case 34: jj_3_35(); break;
39841             case 35: jj_3_36(); break;
39842             case 36: jj_3_37(); break;
39843             case 37: jj_3_38(); break;
39844             case 38: jj_3_39(); break;
39845             case 39: jj_3_40(); break;
39846             case 40: jj_3_41(); break;
39847             case 41: jj_3_42(); break;
39848             case 42: jj_3_43(); break;
39849             case 43: jj_3_44(); break;
39850             case 44: jj_3_45(); break;
39851             case 45: jj_3_46(); break;
39852             case 46: jj_3_47(); break;
39853             case 47: jj_3_48(); break;
39854             case 48: jj_3_49(); break;
39855             case 49: jj_3_50(); break;
39856             case 50: jj_3_51(); break;
39857             case 51: jj_3_52(); break;
39858             case 52: jj_3_53(); break;
39859             case 53: jj_3_54(); break;
39860             case 54: jj_3_55(); break;
39861             case 55: jj_3_56(); break;
39862             case 56: jj_3_57(); break;
39863             case 57: jj_3_58(); break;
39864             case 58: jj_3_59(); break;
39865             case 59: jj_3_60(); break;
39866             case 60: jj_3_61(); break;
39867             case 61: jj_3_62(); break;
39868             case 62: jj_3_63(); break;
39869             case 63: jj_3_64(); break;
39870             case 64: jj_3_65(); break;
39871             case 65: jj_3_66(); break;
39872             case 66: jj_3_67(); break;
39873             case 67: jj_3_68(); break;
39874             case 68: jj_3_69(); break;
39875             case 69: jj_3_70(); break;
39876             case 70: jj_3_71(); break;
39877             case 71: jj_3_72(); break;
39878             case 72: jj_3_73(); break;
39879             case 73: jj_3_74(); break;
39880             case 74: jj_3_75(); break;
39881             case 75: jj_3_76(); break;
39882             case 76: jj_3_77(); break;
39883             case 77: jj_3_78(); break;
39884             case 78: jj_3_79(); break;
39885             case 79: jj_3_80(); break;
39886             case 80: jj_3_81(); break;
39887             case 81: jj_3_82(); break;
39888             case 82: jj_3_83(); break;
39889           }
39890         }
39891         p = p.next;
39892       } while (p != null);
39893       } catch(LookaheadSuccess ls) { }
39894     }
39895     jj_rescan = false;
39896   }
39897 
39898   private void jj_save(int index, int xla) {
39899     JJCalls p = jj_2_rtns[index];
39900     while (p.gen > jj_gen) {
39901       if (p.next == null) { p = p.next = new JJCalls(); break; }
39902       p = p.next;
39903     }
39904     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
39905   }
39906 
39907   static final class JJCalls {
39908     int gen;
39909     Token first;
39910     int arg;
39911     JJCalls next;
39912   }
39913 
39914 }